Changeset a35b458 in mainline for kernel/test/synch/rcu1.c

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:

• kernel/test/synch/rcu1.c (modified) (55 diffs)

kernel/test/synch/rcu1.c

@@ -67 +67 @@
                 TPRINTF(".");
         }
-        
+
         if (!p->exited) {
                 *presult = ETIMEOUT;
@@ -81 +81 @@
 {
         assert(thread[k] == NULL);
-        
+
         thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE,
                 "test-rcu-thread");
-                
+
         if(thread[k]) {
                 /* Distribute evenly. */
@@ -95 +95 @@
 {
         size_t thread_cnt = get_thread_cnt();
-        
+
         one_idx = 0;
-        
+
         for (size_t i = 0; i < thread_cnt; ++i) {
                 run_thread(i, func, NULL);
@@ -106 +106 @@
 {
         size_t thread_cnt = get_thread_cnt();
-        
+
         one_idx = 0;
-        
+
         for (size_t i = 0; i < thread_cnt; ++i) {
                 if (thread[i]) {
@@ -115 +115 @@
                                 errno_t ret = thread_join_timeout(thread[i], 5 * 1000 * 1000, 0);
                                 joined = (ret != ETIMEOUT);
-                                
+
                                 if (ret == EOK) {
                                         TPRINTF("%zu threads remain\n", thread_cnt - i - 1);
                                 }
                         } while (!joined);
-                        
+
                         thread_detach(thread[i]);
                         thread[i] = NULL;
@@ -140 +140 @@
 
         --one_idx;
-        
+
         if (thread[one_idx]) {
                 thread_join(thread[one_idx]);
@@ -154 +154 @@
 {
         size_t nop_iters = (size_t)arg;
-        
+
         TPRINTF("Enter nop-reader\n");
-        
+
         for (size_t i = 0; i < nop_iters; ++i) {
                 rcu_read_lock();
                 rcu_read_unlock();
         }
-        
+
         TPRINTF("Exit nop-reader\n");
 }
@@ -169 +169 @@
         assert(0 < steps && from <= to && 0 < to);
         size_t inc = (to - from) / (steps - 1);
-        
+
         for (size_t i = 0; i < steps - 1; ++i) {
                 seq[i] = i * inc + from;
         }
-        
+
         seq[steps - 1] = to;
 }
@@ -181 +181 @@
         size_t seq[MAX_THREADS] = {0};
         get_seq(100, 100000, get_thread_cnt(), seq);
-        
+
         TPRINTF("\nRun %zu thr: repeat empty no-op reader sections\n", get_thread_cnt());
-        
+
         for (size_t k = 0; k < get_thread_cnt(); ++k)
                 run_one(nop_reader, (void*)seq[k]);
-        
+
         TPRINTF("\nJoining %zu no-op readers\n", get_thread_cnt());
         join_all();
-        
+
         return true;
 }
@@ -202 +202 @@
         size_t nop_iters = (size_t)arg;
         size_t outer_iters = iter_cnt / nop_iters;
-        
+
         TPRINTF("Enter long-reader\n");
-        
+
         for (size_t i = 0; i < outer_iters; ++i) {
                 rcu_read_lock();
-                
+
                 for (volatile size_t k = 0; k < nop_iters; ++k) {
                         /* nop, but increment volatile k */
                 }
-                
+
                 rcu_read_unlock();
         }
-        
+
         TPRINTF("Exit long-reader\n");
 }
@@ -222 +222 @@
         size_t seq[MAX_THREADS] = {0};
         get_seq(10, 1000 * 1000, get_thread_cnt(), seq);
-        
+
         TPRINTF("\nRun %zu thr: repeat long reader sections, will preempt, no cbs.\n",
                 get_thread_cnt());
-        
+
         for (size_t k = 0; k < get_thread_cnt(); ++k)
                 run_one(long_reader, (void*)seq[k]);
-        
+
         TPRINTF("\nJoining %zu readers with long reader sections.\n", get_thread_cnt());
         join_all();
-        
+
         return true;
 }
@@ -253 +253 @@
                 rcu_item_t *a = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
                 rcu_item_t *b = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
-                
+
                 if (a && b) {
                         rcu_call(a, count_cb);
@@ -272 +272 @@
         size_t exp_cnt = nop_updater_iters * get_thread_cnt();
         size_t max_used_mem = sizeof(rcu_item_t) * exp_cnt;
-        
+
         TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n",
                 get_thread_cnt(), exp_cnt, max_used_mem);
-        
+
         run_all(nop_updater);
         TPRINTF("\nJoining %zu no-op callback threads\n", get_thread_cnt());
         join_all();
-        
+
         size_t loop_cnt = 0, max_loops = 15;
 
@@ -287 +287 @@
                 thread_sleep(1);
         }
-        
+
         return loop_cnt < max_loops;
 }
@@ -312 +312 @@
 {
         TPRINTF("Enter one-cb-reader\n");
-        
-        rcu_read_lock();
-        
+
+        rcu_read_lock();
+
         item_w_cookie_t *item = malloc(sizeof(item_w_cookie_t), FRAME_ATOMIC);
-        
+
         if (item) {
                 item->cookie = magic_cookie;
@@ -323 +323 @@
                 TPRINTF("\n[out-of-mem]\n");
         }
-        
+
         thread_sleep(1);
-        
+
         rcu_read_unlock();
-        
+
         TPRINTF("Exit one-cb-reader\n");
 }
@@ -334 +334 @@
 {
         one_cb_is_done = 0;
-        
+
         TPRINTF("\nRun a single reader that posts one callback.\n");
         run_one(one_cb_reader, NULL);
         join_one();
-        
+
         TPRINTF("\nJoined one-cb reader, wait for callback.\n");
         size_t loop_cnt = 0;
         size_t max_loops = 4; /* 200 ms total */
-        
+
         while (!one_cb_is_done && loop_cnt < max_loops) {
                 thread_usleep(50 * 1000);
                 ++loop_cnt;
         }
-        
+
         return one_cb_is_done;
 }
@@ -373 +373 @@
 {
         seq_item_t *item = member_to_inst(rcu_item, seq_item_t, rcu);
-        
+
         /* Racy but errs to the conservative side, so it is ok. */
         if (max_upd_done_time < item->start_time) {
                 max_upd_done_time = item->start_time;
-                
+
                 /* Make updated time visible */
                 memory_barrier();
@@ -393 +393 @@
 #ifndef KARCH_riscv64
         seq_work_t *work = (seq_work_t*)arg;
-        
+
         /* Alternate between reader and updater roles. */
         for (size_t k = 0; k < work->iters; ++k) {
@@ -400 +400 @@
                         rcu_read_lock();
                         atomic_count_t start_time = atomic_postinc(&cur_time);
-                        
+
                         for (volatile size_t d = 0; d < 10 * i; ++d ){
                                 /* no-op */
                         }
-                        
+
                         /* Get most recent max_upd_done_time. */
                         memory_barrier();
-                        
+
                         if (start_time < max_upd_done_time) {
                                 seq_test_result = ERACE;
                         }
-                        
+
                         rcu_read_unlock();
-                        
+
                         if (seq_test_result != EOK)
                                 return;
                 }
-                
+
                 /* Updater */
                 for (size_t i = 0; i < work->update_cnt; ++i) {
                         seq_item_t *a = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
                         seq_item_t *b = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
-                        
+
                         if (a && b) {
                                 a->start_time = atomic_postinc(&cur_time);
                                 rcu_call(&a->rcu, seq_cb);
-                                
+
                                 b->start_time = atomic_postinc(&cur_time);
                                 rcu_call(&b->rcu, seq_cb);
@@ -437 +437 @@
                         }
                 }
-                
+
         }
 #else
@@ -454 +454 @@
         size_t read_cnt[MAX_THREADS] = {0};
         seq_work_t item[MAX_THREADS];
-        
+
         size_t total_cbs = 0;
         size_t max_used_mem = 0;
-        
+
         get_seq(0, total_cnt, get_thread_cnt(), read_cnt);
-        
+
 
         for (size_t i = 0; i < get_thread_cnt(); ++i) {
@@ -465 +465 @@
                 item[i].read_cnt = read_cnt[i];
                 item[i].iters = iters;
-                
+
                 total_cbs += 2 * iters * item[i].update_cnt;
         }
-        
+
         max_used_mem = total_cbs * sizeof(seq_item_t);
 
@@ -474 +474 @@
         uint64_t mem_units;
         bin_order_suffix(max_used_mem, &mem_units, &mem_suffix, false);
-        
+
         TPRINTF("\nRun %zu th: check callback completion time in readers. "
                 "%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n",
                 get_thread_cnt(), total_cbs, mem_units, mem_suffix);
-        
+
         for (size_t i = 0; i < get_thread_cnt(); ++i) {
                 run_one(seq_func, &item[i]);
         }
-        
+
         TPRINTF("\nJoining %zu seq-threads\n", get_thread_cnt());
         join_all();
-        
+
         if (seq_test_result == ENOMEM) {
                 TPRINTF("\nErr: out-of mem\n");
@@ -491 +491 @@
                 TPRINTF("\nERROR: race detected!!\n");
         }
-        
+
         return seq_test_result == EOK;
 }
@@ -510 +510 @@
         rcu_read_lock();
         rcu_read_unlock();
-        
+
         rcu_call((rcu_item_t*)arg, reader_unlocked);
-        
-        rcu_read_lock();
-        rcu_read_lock();
-        
+
+        rcu_read_lock();
+        rcu_read_lock();
+
         /* Exit without unlocking the rcu reader section. */
 }
@@ -522 +522 @@
 {
         TPRINTF("\nReader exits thread with rcu_lock\n");
-        
+
         exited_t *p = malloc(sizeof(exited_t), FRAME_ATOMIC);
         if (!p) {
@@ -528 +528 @@
                 return false;
         }
-                
+
         p->exited = false;
-        
+
         run_one(reader_exit, p);
         join_one();
-        
+
         errno_t result = EOK;
         wait_for_cb_exit(2 /* secs */, p, &result);
-        
+
         if (result != EOK) {
                 TPRINTF("Err: RCU locked up after exiting from within a reader\n");
@@ -543 +543 @@
                 free(p);
         }
-        
+
         return result == EOK;
 }
@@ -570 +570 @@
 
         TPRINTF("reader_prev{ ");
-        
+
         rcu_read_lock();
         scheduler();
@@ -588 +588 @@
         preempt_t *p = (preempt_t*)arg;
         assert(!p->e.exited);
-        
+
         TPRINTF("reader_inside_cur{ ");
         /*
@@ -613 +613 @@
         preempt_t *p = (preempt_t*)arg;
         assert(!p->e.exited);
-        
+
         TPRINTF("reader_cur{ ");
         rcu_read_lock();
@@ -622 +622 @@
         /* Preempt while cur GP detection is running */
         thread_sleep(1);
-        
+
         /* Err: exited before this reader completed. */
         if (p->e.exited)
@@ -635 +635 @@
         preempt_t *p = (preempt_t*)arg;
         assert(!p->e.exited);
-        
+
         TPRINTF("reader_next1{ ");
         rcu_read_lock();
@@ -641 +641 @@
         /* Preempt before cur GP detection starts. */
         scheduler();
-        
+
         /* Start GP. */
         rcu_call(&p->e.rcu, preempted_unlocked);
@@ -657 +657 @@
         preempt_t *p = (preempt_t*)arg;
         assert(!p->e.exited);
-        
+
         TPRINTF("reader_next2{ ");
         rcu_read_lock();
@@ -663 +663 @@
         /* Preempt before cur GP detection starts. */
         scheduler();
-        
+
         /* Start GP. */
         rcu_call(&p->e.rcu, preempted_unlocked);
@@ -691 +691 @@
                 return false;
         }
-        
+
         p->e.exited = false;
         p->result = EOK;
-        
+
         run_one(f, p);
         join_one();
-        
+
         /* Wait at most 4 secs. */
         wait_for_cb_exit(4, &p->e, &p->result);
-        
+
         if (p->result == EOK) {
                 free(p);
@@ -714 +714 @@
 {
         TPRINTF("\nReaders will be preempted.\n");
-        
+
         bool success = true;
         bool ok = true;
-        
+
         ok = do_one_reader_preempt(preempted_reader_prev,
                 "Err: preempted_reader_prev()\n");
         success = success && ok;
-        
+
         ok = do_one_reader_preempt(preempted_reader_inside_cur,
                 "Err: preempted_reader_inside_cur()\n");
         success = success && ok;
-        
+
         ok = do_one_reader_preempt(preempted_reader_cur,
                 "Err: preempted_reader_cur()\n");
         success = success && ok;
-        
+
         ok = do_one_reader_preempt(preempted_reader_next1,
                 "Err: preempted_reader_next1()\n");
@@ -737 +737 @@
                 "Err: preempted_reader_next2()\n");
         success = success && ok;
-        
+
         return success;
 }
@@ -751 +751 @@
 {
         synch_t *synch = (synch_t *) arg;
-        
+
         rcu_read_lock();
 
         /* Order accesses of synch after the reader section begins. */
         memory_barrier();
-        
+
         synch->reader_running = true;
-        
+
         while (!synch->synch_running) {
                 /* 0.5 sec */
                 delay(500 * 1000);
         }
-        
+
         /* Run for 1 sec */
         delay(1000 * 1000);
         /* thread_join() propagates done to do_synch() */
         synch->reader_done = true;
-        
+
         rcu_read_unlock();
 }
@@ -776 +776 @@
 {
         TPRINTF("\nSynchronize with long reader\n");
-        
+
         synch_t *synch = malloc(sizeof(synch_t), FRAME_ATOMIC);
-        
+
         if (!synch) {
                 TPRINTF("[out-of-mem]\n");
                 return false;
         }
-        
+
         synch->reader_done = false;
         synch->reader_running = false;
         synch->synch_running = false;
-        
+
         run_one(synch_reader, synch);
-        
+
         /* Wait for the reader to enter its critical section. */
         scheduler();
@@ -795 +795 @@
                 thread_usleep(500 * 1000);
         }
-        
+
         synch->synch_running = true;
-        
+
         rcu_synchronize();
         join_one();
-        
-        
+
+
         if (synch->reader_done) {
                 free(synch);
@@ -827 +827 @@
 {
         TPRINTF("\nrcu_barrier: Wait for outstanding rcu callbacks to complete\n");
-        
+
         barrier_t *barrier = malloc(sizeof(barrier_t), FRAME_ATOMIC);
-        
+
         if (!barrier) {
                 TPRINTF("[out-of-mem]\n");
                 return false;
         }
-        
+
         atomic_set(&barrier->done, 0);
-        
+
         rcu_call(&barrier->rcu_item, barrier_callback);
         rcu_barrier();
-        
+
         if (1 == atomic_get(&barrier->done)) {
                 free(barrier);
@@ -861 +861 @@
 {
         bool *done = (bool*) arg;
-        
+
         while (!*done) {
                 rcu_read_lock();
                 rcu_read_unlock();
-                
+
                 /*
                  * Do some work outside of the reader section so we are not always
@@ -884 +884 @@
 {
         stress_t *s = (stress_t *)arg;
-        
+
         for (size_t i = 0; i < s->iters; ++i) {
                 rcu_item_t *item = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
-                
+
                 if (item) {
                         rcu_call(item, stress_cb);
@@ -894 +894 @@
                         return;
                 }
-                
+
                 /* Print a dot if we make a progress of 1% */
                 if (s->master && 0 == (i % (s->iters/100)))
@@ -907 +907 @@
         stress_t master = { .iters = cb_per_thread, .master = true };
         stress_t worker = { .iters = cb_per_thread, .master = false };
-        
+
         size_t thread_cnt = min(MAX_THREADS / 2, config.cpu_active);
         /* Each cpu has one reader and one updater. */
         size_t reader_cnt = thread_cnt;
         size_t updater_cnt = thread_cnt;
-        
+
         size_t exp_upd_calls = updater_cnt * cb_per_thread;
         size_t max_used_mem = exp_upd_calls * sizeof(rcu_item_t);
-        
+
         const char *mem_suffix;
         uint64_t mem_units;
@@ -923 +923 @@
                 " total (max %" PRIu64 " %s used). Be very patient.\n",
                 reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
-        
+
         for (size_t k = 0; k < reader_cnt; ++k) {
                 run_one(stress_reader, &done);
@@ -931 +931 @@
                 run_one(stress_updater, k > 0 ? &worker : &master);
         }
-        
+
         TPRINTF("\nJoining %zu stress updaters.\n", updater_cnt);
-        
+
         for (size_t k = 0; k < updater_cnt; ++k) {
                 join_one();
         }
-        
+
         done = true;
 
         TPRINTF("\nJoining %zu stress nop-readers.\n", reader_cnt);
-        
+
         join_all();
         return true;
@@ -957 +957 @@
 {
         expedite_t *e = (expedite_t *)arg;
-        
+
         if (1 < e->count_down) {
                 --e->count_down;
-                
+
                 if (0 == (e->count_down % (e->total_cnt/100))) {
                         TPRINTF("*");
                 }
-                
+
                 _rcu_call(e->expedite, &e->r, expedite_cb);
         } else {
@@ -979 +979 @@
         e.count_down = cnt;
         e.expedite = exp;
-        
+
         _rcu_call(e.expedite, &e.r, expedite_cb);
-        
+
         while (0 < e.count_down) {
                 thread_sleep(1);
@@ -992 +992 @@
         size_t exp_cnt = 1000 * 1000;
         size_t normal_cnt = 1 * 1000;
-        
+
         TPRINTF("Expedited: sequence of %zu rcu_calls\n", exp_cnt);
         run_expedite(true, exp_cnt);
@@ -1024 +1024 @@
                 { 0, NULL, NULL }
         };
-        
+
         bool success = true;
         bool ok = true;
         uint64_t completed_gps = rcu_completed_gps();
         uint64_t delta_gps = 0;
-        
+
         for (int i = 0; test_func[i].func; ++i) {
                 if (!test_func[i].include) {
@@ -1037 +1037 @@
                         TPRINTF("\nRunning subtest %s.\n", test_func[i].desc);
                 }
-                
+
                 ok = test_func[i].func();
                 success = success && ok;
-                
+
                 delta_gps = rcu_completed_gps() - completed_gps;
                 completed_gps += delta_gps;