Changeset a35b458 in mainline for uspace/app/rcutest/rcutest.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:

• uspace/app/rcutest/rcutest.c (modified) (50 diffs)

uspace/app/rcutest/rcutest.c

@@ -174 +174 @@
 {
         fid_t fid = fibril_create(func, arg);
-        
+
         if (0 == fid) {
                 printf("Failed to create a fibril!\n");
                 return false;
         }
-        
+
         fibril_add_ready(fid);
         return true;
@@ -190 +190 @@
         size_t failed_cnt = 0;
         size_t ok_cnt = 0;
-        
+
         for (size_t i = 0; i < test_desc_cnt; ++i) {
                 test_desc_t *t = &test_desc[i];
-                
+
                 if (t->func && !t->aggregate && include_filter(t)) {
                         printf("Running \'%s\'...\n", t->name);
                         bool ok = test_desc[i].func(info);
-                        
+
                         if (ok) {
                                 ++ok_cnt;
@@ -207 +207 @@
                 }
         }
-        
+
         printf("\n");
 
@@ -215 +215 @@
                 printf("%zu tests failed\n", failed_cnt);
         }
-        
+
         return 0 == failed_cnt;
 }
@@ -273 +273 @@
         /* nop */
         rcu_read_unlock();
-        
+
         rcu_synchronize();
 
@@ -284 +284 @@
         fibril_yield();
         rcu_read_unlock();
-        
+
         fibril_yield();
         rcu_synchronize();
         rcu_synchronize();
-        
+
         rcu_read_lock();
         /* nop */
@@ -295 +295 @@
 
         rcu_read_unlock();
-        
+
         return !rcu_read_locked();
 }
@@ -312 +312 @@
 {
         rcu_register_fibril();
-        
+
         printf("lock{");
         rcu_read_lock();
@@ -324 +324 @@
         ++arg->done_sleeps_cnt;
         printf("}");
-        
+
         if (arg->synched) {
                 arg->failed = 1;
                 printf("Error: rcu_sync exited prematurely.\n");
         }
-        
+
         arg->exited_cs = true;
         rcu_read_unlock();
         printf("}");
-        
+
         rcu_deregister_fibril();
         return 0;
@@ -341 +341 @@
 {
         one_reader_info_t info = { 0 };
-        
+
         if (!create_fibril((fibril_func_t) sleeping_reader, &info))
                 return false;
-        
+
         /* 1 sec, waits for the reader to enter its critical section and sleep. */
         async_usleep(1 * USECS_PER_SEC);
-        
+
         if (!info.entered_cs || info.exited_cs) {
                 printf("Error: reader is unexpectedly outside of critical section.\n");
                 return false;
         }
-        
+
         info.synching = true;
         printf("sync[");
@@ -361 +361 @@
         /* Load info.exited_cs */
         memory_barrier();
-        
+
         if (!info.exited_cs || info.failed) {
                 printf("Error: rcu_sync() returned before the reader exited its CS.\n");
@@ -394 +394 @@
 {
         rcu_register_fibril();
-        
+
         printf("old-lock{");
         rcu_read_lock();
         arg->old_entered_cs = true;
-        
+
         printf("wait-for-sync{");
         /* Wait for rcu_sync() to start waiting for us. */
@@ -405 +405 @@
         }
         printf(" }");
-        
+
         /* A new reader starts while rcu_sync() is in progress. */
-        
+
         printf("wait-for-new-R{");
         /* Wait for the new reader to enter its reader section. */
@@ -414 +414 @@
         }
         printf(" }");
-        
+
         arg->old_exited_cs = true;
-        
+
         assert(!arg->new_exited_cs);
-        
+
         if (arg->synched) {
                 arg->failed = 1;
                 printf("Error: rcu_sync() did not wait for preexisting reader.\n");
         }
-        
+
         rcu_read_unlock();
         printf(" }");
-        
+
         rcu_deregister_fibril();
         return 0;
@@ -434 +434 @@
 {
         rcu_register_fibril();
-        
+
         /* Wait until rcu_sync() starts. */
         while (!arg->synching) {
                 async_usleep(WAIT_STEP_US);
         }
-        
+
         /*
          * synching is set when rcu_sync() is about to be entered so wait
@@ -445 +445 @@
          */
         async_usleep(WAIT_STEP_US);
-        
+
         printf("new-lock(");
         rcu_read_lock();
@@ -454 +454 @@
                 async_usleep(WAIT_STEP_US);
         }
-        
+
         arg->new_exited_cs = true;
         /* Write new_exited_cs before exiting reader section. */
         memory_barrier();
-        
+
         /*
          * Preexisting reader should have exited by now, so rcu_synchronize()
@@ -467 +467 @@
                 printf("Error: preexisting reader should have exited by now!\n");
         }
-        
+
         rcu_read_unlock();
         printf(")");
@@ -478 +478 @@
 {
         two_reader_info_t info = { 0 };
-        
+
         if (!create_fibril((fibril_func_t) preexisting_reader, &info))
                 return false;
@@ -484 +484 @@
         if (!create_fibril((fibril_func_t) new_reader, &info))
                 return false;
-        
+
         /* Waits for the preexisting_reader to enter its CS.*/
         while (!info.old_entered_cs) {
                 async_usleep(WAIT_STEP_US);
         }
-        
+
         assert(!info.old_exited_cs);
         assert(!info.new_entered_cs);
         assert(!info.new_exited_cs);
-        
+
         printf("sync[");
         info.synching = true;
         rcu_synchronize();
         printf(" ]");
-        
+
         /* Load info.exited_cs */
         memory_barrier();
-        
+
         if (!info.old_exited_cs) {
                 printf("Error: rcu_sync() returned before preexisting reader exited.\n");
                 info.failed = 1;
         }
-        
+
         bool new_outside_cs = !info.new_entered_cs || info.new_exited_cs;
-        
+
         /* Test if new reader is waiting in CS before setting synched. */
         compiler_barrier();
         info.synched = true;
-                
+
         if (new_outside_cs) {
                 printf("Error: new reader CS held up rcu_sync(). (4)\n");
@@ -519 +519 @@
                 /* Wait for the new reader. */
                 rcu_synchronize();
-                
+
                 if (!info.new_exited_cs) {
                         printf("Error: 2nd rcu_sync() returned before new reader exited.\n");
                         info.failed = 1;
                 }
-                
+
                 printf("\n");
         }
-        
+
         if (info.failed) {
                 /*
@@ -535 +535 @@
                 async_usleep(WAIT_STEP_US);
         }
-        
+
         return 0 == info.failed;
 }
@@ -555 +555 @@
 {
         rcu_register_fibril();
-        
+
         printf("old-lock{");
         rcu_read_lock();
@@ -561 +561 @@
         rcu_read_lock();
         arg->entered_cs = true;
-        
+
         printf("wait-for-sync{");
         /* Wait for rcu_sync() to start waiting for us. */
@@ -568 +568 @@
         }
         printf(" }");
-        
+
         rcu_read_unlock();
         printf(" }");
@@ -575 +575 @@
         /* Store exited_cs before unlocking reader section in deregister. */
         memory_barrier();
-        
+
         /* Deregister forcefully unlocks the reader section. */
         rcu_deregister_fibril();
@@ -585 +585 @@
 {
         exit_reader_info_t info = { 0 };
-        
+
         if (!create_fibril((fibril_func_t) exiting_locked_reader, &info))
                 return false;
-        
+
         /* Waits for the preexisting_reader to enter its CS.*/
         while (!info.entered_cs) {
                 async_usleep(WAIT_STEP_US);
         }
-        
+
         assert(!info.exited_cs);
-        
+
         printf("sync[");
         info.synching = true;
@@ -601 +601 @@
         info.synched = true;
         printf(" ]\n");
-        
+
         /* Load info.exited_cs */
         memory_barrier();
-        
+
         if (!info.exited_cs) {
                 printf("Error: rcu_deregister_fibril did not unlock the CS.\n");
                 return false;
         }
-        
+
         return true;
 }
@@ -621 +621 @@
         atomic_t time;
         atomic_t max_start_time_of_done_sync;
-        
+
         size_t total_workers;
         size_t done_reader_cnt;
@@ -630 +630 @@
         size_t read_iters;
         size_t upd_iters;
-        
+
         atomic_t seed;
         int failed;
@@ -640 +640 @@
         fibril_mutex_lock(&arg->done_cnt_mtx);
         ++*cnt;
-        
+
         if (arg->total_workers == arg->done_reader_cnt + arg->done_updater_cnt) {
                 fibril_condvar_signal(&arg->done_cnt_changed);
         }
-        
+
         fibril_mutex_unlock(&arg->done_cnt_mtx);
 }
@@ -651 +651 @@
 {
         rcu_register_fibril();
-        
+
         size_t seed = (size_t) atomic_preinc(&arg->seed);
         bool first = (seed == 1);
-        
+
         for (size_t k = 0; k < arg->read_iters; ++k) {
                 /* Print progress if the first reader fibril. */
@@ -660 +660 @@
                         printf(".");
                 }
-                
+
                 rcu_read_lock();
                 atomic_count_t start_time = atomic_preinc(&arg->time);
-                
+
                 /* Do some work. */
                 seed = next_rand(seed);
                 size_t idle_iters = seed % 8;
-                
+
                 for (size_t i = 0; i < idle_iters; ++i) {
                         fibril_yield();
                 }
-                
+
                 /*
                  * Check if the most recently started rcu_sync of the already
@@ -681 +681 @@
                         arg->failed = 1;
                 }
-                
+
                 rcu_read_unlock();
         }
-        
+
         rcu_deregister_fibril();
 
@@ -694 +694 @@
 {
         rcu_register_fibril();
-        
+
         for (size_t k = 0; k < arg->upd_iters; ++k) {
                 atomic_count_t start_time = atomic_get(&arg->time);
                 rcu_synchronize();
-                
+
                 /* This is prone to a race but if it happens it errs to the safe side.*/
                 if (atomic_get(&arg->max_start_time_of_done_sync) < start_time) {
@@ -704 +704 @@
                 }
         }
-        
+
         rcu_deregister_fibril();
-        
+
         signal_seq_fibril_done(arg, &arg->done_updater_cnt);
         return 0;
@@ -715 +715 @@
         size_t reader_cnt = test_info->thread_cnt;
         size_t updater_cnt = test_info->thread_cnt;
-                
+
         seq_test_info_t info = {
                 .time = {0},
@@ -729 +729 @@
                 .failed = 0,
         };
-        
+
         /* Create and start worker fibrils. */
         for (size_t k = 0; k + k < reader_cnt + updater_cnt; ++k) {
                 bool ok = create_fibril((fibril_func_t) seq_reader, &info);
                 ok = ok && create_fibril((fibril_func_t) seq_updater, &info);
-                
+
                 if (!ok) {
                         /* Let the already created fibrils corrupt the stack. */
@@ -740 +740 @@
                 }
         }
-        
+
         /* Wait for all worker fibrils to complete their work. */
         fibril_mutex_lock(&info.done_cnt_mtx);
-        
+
         while (info.total_workers != info.done_reader_cnt + info.done_updater_cnt) {
                 fibril_condvar_wait(&info.done_cnt_changed, &info.done_cnt_mtx);
         }
-        
+
         fibril_mutex_unlock(&info.done_cnt_mtx);
-        
+
         if (info.failed) {
                 printf("Error: rcu_sync() did not wait for a preexisting reader.");
         }
-        
+
         return 0 == info.failed;
 }
@@ -772 +772 @@
         /* Sanity check. */
         assert(cnt < 1024);
-        
+
         /* Keep this mutex locked so that dummy fibrils never exit. */
         bool success = fibril_mutex_trylock(&blocking_mtx);
         assert(success);
-        
+
         for (size_t k = 0; k < cnt; ++k) {
                 thread_id_t tid;
-                
+
                 errno_t ret = thread_create(dummy_fibril, NULL, "urcu-test-worker", &tid);
                 if (EOK != ret) {
@@ -786 +786 @@
                 }
         }
-        
+
         return true;
 }
@@ -796 +796 @@
         for (size_t k = 0; k < test_desc_cnt; ++k) {
                 test_desc_t *t = &test_desc[k];
-                
+
                 if (t->func && 0 == str_cmp(t->name, name))
                         return t;
         }
-        
+
         /* Try to match the test number. */
         uint32_t test_num = 0;
-        
+
         if (EOK == str_uint32_t(name, NULL, 0, true, &test_num)) {
                 if (test_num < test_desc_cnt && test_desc[test_num].func) {
@@ -809 +809 @@
                 }
         }
-        
+
         return NULL;
 }
@@ -816 +816 @@
 {
         printf("Available tests: \n");
-        
+
         for (size_t i = 0; i < test_desc_cnt; ++i) {
                 test_desc_t *t = &test_desc[i];
-                
+
                 if (!t->func)
                         continue;
-                
+
                 const char *type = "";
-                
+
                 if (t->type == T_SANITY)
                         type = " (sanity)";
@@ -839 +839 @@
         printf("Usage: rcutest [test_name|test_number] {number_of_threads}\n");
         list_tests();
-        
+
         printf("\nExample usage:\n");
         printf("\trcutest *\n");
@@ -852 +852 @@
                 return false;
         }
-        
+
         info->desc = find_test(argv[1]);
 
@@ -860 +860 @@
                 return false;
         }
-        
+
         if (argc == 3) {
                 uint32_t thread_cnt = 0;
                 errno_t ret = str_uint32_t(argv[2], NULL, 0, true, &thread_cnt);
-                
+
                 if (ret == EOK && 1 <= thread_cnt && thread_cnt <= 64) {
                         info->thread_cnt = thread_cnt;
@@ -874 +874 @@
                 info->thread_cnt = 1;
         }
-        
+
         return true;
 }
@@ -881 +881 @@
 {
         rcu_register_fibril();
-        
+
         test_info_t info;
-        
+
         bool ok = parse_cmd_line(argc, argv, &info);
         ok = ok && create_threads(info.thread_cnt - 1);
-        
+
         if (ok) {
                 assert(1 <= info.thread_cnt);
                 test_desc_t *t = info.desc;
-                
+
                 printf("Running '%s' (in %zu threads)...\n", t->name, info.thread_cnt);
                 ok = t->func(&info);
@@ -897 +897 @@
 
                 rcu_deregister_fibril();
-                
+
                 /* Let the kernel clean up the created background threads. */
                 return ok ? 0 : 1;