Changes in kernel/test/synch/rcu1.c [a35b458:1b20da0] in mainline

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;