Changeset 3bacee1 in mainline for kernel/test/synch/rcu1.c

Timestamp:

2018-04-12T16:27:17Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

3cf22f9

Parents:

76d0981d

git-author:

Jiri Svoboda <jiri@…> (2018-04-11 19:25:33)

git-committer:

Jiri Svoboda <jiri@…> (2018-04-12 16:27:17)

Message:

Make ccheck-fix again and commit more good files.

File:

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

kernel/test/synch/rcu1.c

@@ -78 +78 @@
 }
 
-static void run_thread(size_t k, void (*func)(void*), void *arg)
+static void run_thread(size_t k, void (*func)(void *), void *arg)
 {
         assert(thread[k] == NULL);
 
         thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE,
-                "test-rcu-thread");
-
-        if(thread[k]) {
+            "test-rcu-thread");
+
+        if (thread[k]) {
                 /* Distribute evenly. */
                 thread_wire(thread[k], &cpus[k % config.cpu_active]);
@@ -92 +92 @@
 }
 
-static void run_all(void (*func)(void*))
+static void run_all(void (*func)(void *))
 {
         size_t thread_cnt = get_thread_cnt();
@@ -127 +127 @@
 }
 
-static void run_one(void (*func)(void*), void *arg)
+static void run_one(void (*func)(void *), void *arg)
 {
         assert(one_idx < MAX_THREADS);
@@ -179 +179 @@
 static bool do_nop_readers(void)
 {
-        size_t seq[MAX_THREADS] = {0};
+        size_t seq[MAX_THREADS] = { 0 };
         get_seq(100, 100000, get_thread_cnt(), seq);
 
@@ -185 +185 @@
 
         for (size_t k = 0; k < get_thread_cnt(); ++k)
-                run_one(nop_reader, (void*)seq[k]);
+                run_one(nop_reader, (void *)seq[k]);
 
         TPRINTF("\nJoining %zu no-op readers\n", get_thread_cnt());
@@ -220 +220 @@
 static bool do_long_readers(void)
 {
-        size_t seq[MAX_THREADS] = {0};
+        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());
+            get_thread_cnt());
 
         for (size_t k = 0; k < get_thread_cnt(); ++k)
-                run_one(long_reader, (void*)seq[k]);
+                run_one(long_reader, (void *)seq[k]);
 
         TPRINTF("\nJoining %zu readers with long reader sections.\n", get_thread_cnt());
@@ -238 +238 @@
 
 
-static atomic_t nop_callbacks_cnt = {0};
+static atomic_t nop_callbacks_cnt = { 0 };
 /* Must be even. */
 static const int nop_updater_iters = 10000;
@@ -250 +250 @@
 static void nop_updater(void *arg)
 {
-        for (int i = 0; i < nop_updater_iters; i += 2){
+        for (int i = 0; i < nop_updater_iters; i += 2) {
                 rcu_item_t *a = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
                 rcu_item_t *b = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
@@ -274 +274 @@
 
         TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n",
-                get_thread_cnt(), exp_cnt, max_used_mem);
+            get_thread_cnt(), exp_cnt, max_used_mem);
 
         run_all(nop_updater);
@@ -303 +303 @@
 static void one_cb_done(rcu_item_t *item)
 {
-        assert( ((item_w_cookie_t *)item)->cookie == magic_cookie);
+        assert(((item_w_cookie_t *)item)->cookie == magic_cookie);
         one_cb_is_done = 1;
         TPRINTF("Callback()\n");
@@ -367 +367 @@
 static errno_t seq_test_result = EOK;
 
-static atomic_t cur_time = {1};
-static atomic_count_t max_upd_done_time = {0};
+static atomic_t cur_time = { 1 };
+static atomic_count_t max_upd_done_time = { 0 };
 
 static void seq_cb(rcu_item_t *rcu_item)
@@ -392 +392 @@
          */
 #ifndef KARCH_riscv64
-        seq_work_t *work = (seq_work_t*)arg;
+        seq_work_t *work = (seq_work_t *)arg;
 
         /* Alternate between reader and updater roles. */
@@ -401 +401 @@
                         atomic_count_t start_time = atomic_postinc(&cur_time);
 
-                        for (volatile size_t d = 0; d < 10 * i; ++d ){
+                        for (volatile size_t d = 0; d < 10 * i; ++d) {
                                 /* no-op */
                         }
@@ -452 +452 @@
         const size_t iters = 100;
         const size_t total_cnt = 1000;
-        size_t read_cnt[MAX_THREADS] = {0};
+        size_t read_cnt[MAX_THREADS] = { 0 };
         seq_work_t item[MAX_THREADS];
 
@@ -476 +476 @@
 
         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);
+            "%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) {
@@ -500 +500 @@
 static void reader_unlocked(rcu_item_t *item)
 {
-        exited_t *p = (exited_t*)item;
+        exited_t *p = (exited_t *)item;
         p->exited = true;
 }
@@ -511 +511 @@
         rcu_read_unlock();
 
-        rcu_call((rcu_item_t*)arg, reader_unlocked);
+        rcu_call((rcu_item_t *)arg, reader_unlocked);
 
         rcu_read_lock();
@@ -566 +566 @@
 static void preempted_reader_prev(void *arg)
 {
-        preempt_t *p = (preempt_t*)arg;
+        preempt_t *p = (preempt_t *)arg;
         assert(!p->e.exited);
 
@@ -586 +586 @@
 static void preempted_reader_inside_cur(void *arg)
 {
-        preempt_t *p = (preempt_t*)arg;
+        preempt_t *p = (preempt_t *)arg;
         assert(!p->e.exited);
 
@@ -611 +611 @@
 static void preempted_reader_cur(void *arg)
 {
-        preempt_t *p = (preempt_t*)arg;
+        preempt_t *p = (preempt_t *)arg;
         assert(!p->e.exited);
 
@@ -633 +633 @@
 static void preempted_reader_next1(void *arg)
 {
-        preempt_t *p = (preempt_t*)arg;
+        preempt_t *p = (preempt_t *)arg;
         assert(!p->e.exited);
 
@@ -655 +655 @@
 static void preempted_reader_next2(void *arg)
 {
-        preempt_t *p = (preempt_t*)arg;
+        preempt_t *p = (preempt_t *)arg;
         assert(!p->e.exited);
 
@@ -684 +684 @@
 
 
-static bool do_one_reader_preempt(void (*f)(void*), const char *err)
+static bool do_one_reader_preempt(void (*f)(void *), const char *err)
 {
         preempt_t *p = malloc(sizeof(preempt_t), FRAME_ATOMIC);
@@ -719 +719 @@
 
         ok = do_one_reader_preempt(preempted_reader_prev,
-                "Err: preempted_reader_prev()\n");
+            "Err: preempted_reader_prev()\n");
         success = success && ok;
 
         ok = do_one_reader_preempt(preempted_reader_inside_cur,
-                "Err: preempted_reader_inside_cur()\n");
+            "Err: preempted_reader_inside_cur()\n");
         success = success && ok;
 
         ok = do_one_reader_preempt(preempted_reader_cur,
-                "Err: preempted_reader_cur()\n");
+            "Err: preempted_reader_cur()\n");
         success = success && ok;
 
         ok = do_one_reader_preempt(preempted_reader_next1,
-                "Err: preempted_reader_next1()\n");
+            "Err: preempted_reader_next1()\n");
         success = success && ok;
 
         ok = do_one_reader_preempt(preempted_reader_next2,
-                "Err: preempted_reader_next2()\n");
+            "Err: preempted_reader_next2()\n");
         success = success && ok;
 
@@ -860 +860 @@
 static void stress_reader(void *arg)
 {
-        bool *done = (bool*) arg;
+        bool *done = (bool *) arg;
 
         while (!*done) {
@@ -896 +896 @@
 
                 /* Print a dot if we make a progress of 1% */
-                if (s->master && 0 == (i % (s->iters/100)))
+                if (s->master && 0 == (i % (s->iters / 100)))
                         TPRINTF(".");
         }
@@ -921 +921 @@
 
         TPRINTF("\nStress: Run %zu nop-readers and %zu updaters. %zu callbacks"
-                " total (max %" PRIu64 " %s used). Be very patient.\n",
-                reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
+            " 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) {
@@ -961 +961 @@
                 --e->count_down;
 
-                if (0 == (e->count_down % (e->total_cnt/100))) {
+                if (0 == (e->count_down % (e->total_cnt / 100))) {
                         TPRINTF("*");
                 }
@@ -1046 +1046 @@
                 if (ok) {
                         TPRINTF("\nSubtest %s() ok (GPs: %" PRIu64 ").\n",
-                                test_func[i].desc, delta_gps);
+                            test_func[i].desc, delta_gps);
                 } else {
                         TPRINTF("\nFailed: %s(). Pausing for 5 secs.\n", test_func[i].desc);