Changeset 2e16033 in mainline for kernel/test/synch/rcu1.c

Timestamp:

2012-07-12T16:02:51Z (12 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

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

Children:

c14762e

Parents:

935e28c

Message:

rcu: Fixed memory leak in rcu1 test.

File:

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

kernel/test/synch/rcu1.c

@@ -33 +33 @@
 #include <proc/thread.h>
 #include <macros.h>
+#include <str.h>
 
 #include <synch/rcu.h>
@@ -237 +238 @@
 
 static atomic_t nop_callbacks_cnt = {0};
+/* Must be even. */
 static const int nop_updater_iters = 10000;
 
@@ -247 +249 @@
 static void nop_updater(void *arg)
 {
-        for (int i = 0; i < nop_updater_iters; ++i){
+        for (int i = 0; i < nop_updater_iters; i += 2){
                 rcu_item_t *a = malloc(sizeof(rcu_item_t), 0);
                 rcu_item_t *b = malloc(sizeof(rcu_item_t), 0);
@@ -264 +266 @@
 {
         atomic_set(&nop_callbacks_cnt, 0);
-        
-        TPRINTF("\nRun %zu thr: post many no-op callbacks, no readers.\n", 
-                get_thread_cnt());
+
+        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);
@@ -273 +278 @@
         
         size_t loop_cnt = 0, max_loops = 15;
-        size_t exp_cnt = 2 * nop_updater_iters * get_thread_cnt();
 
         while (exp_cnt != atomic_get(&nop_callbacks_cnt) && loop_cnt < max_loops) {
@@ -309 +313 @@
         
         item_w_cookie_t *item = malloc(sizeof(item_w_cookie_t), 0);
-        item->cookie = magic_cookie;
-        
-        rcu_call(&item->rcu_item, one_cb_done);
+        
+        if (item) {
+                item->cookie = magic_cookie;
+                rcu_call(&item->rcu_item, one_cb_done);
+        } else {
+                TPRINTF("\n[out-of-mem]\n");
+        }
         
         thread_sleep(1);
@@ -330 +338 @@
         TPRINTF("\nJoined one-cb reader, wait for cb.\n");
         size_t loop_cnt = 0;
-        size_t max_loops = 4;
+        size_t max_loops = 4; /* 200 ms */
         
         while (!one_cb_is_done && loop_cnt < max_loops) {
@@ -385 +393 @@
                         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 */
                         }
@@ -403 +411 @@
                 
                 /* Updater */
-                for (size_t i = 0; i < work->update_cnt; i += 2) {
+                for (size_t i = 0; i < work->update_cnt; ++i) {
                         seq_item_t *a = malloc(sizeof(seq_item_t), 0);
                         seq_item_t *b = malloc(sizeof(seq_item_t), 0);
@@ -414 +422 @@
                                 rcu_call(&b->rcu, seq_cb);
                         } else {
-                                /* can leak a bit of mem */
                                 TPRINTF("\n[out-of-mem]\n");
                                 seq_test_result = ENOMEM;
+                                free(a);
+                                free(b);
                                 return;
                         }
@@ -435 +444 @@
         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) {
                 item[i].update_cnt = total_cnt - read_cnt[i];
                 item[i].read_cnt = read_cnt[i];
                 item[i].iters = iters;
-        }
-        
-        TPRINTF("\nRun %zu th: check callback completion time in readers. ~%zu cbs/"
-                "thread. Be patient.\n", get_thread_cnt(),      iters * total_cnt * 2);
+                
+                total_cbs += 2 * iters * item[i].update_cnt;
+        }
+        
+        max_used_mem = total_cbs * sizeof(seq_item_t);
+
+        const char *mem_suffix;
+        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) {
@@ -796 +818 @@
         /* 5 us * 1000 * 1000 iters == 5 sec per updater thread */
         delay(5);
+        free(item);
 }
 
@@ -808 +831 @@
                         rcu_call(item, stress_cb);
                 
+                /* Print a dot if we make progress of 1% */
                 if (s->master && 0 == (i % (s->iters/100 + 1)))
                         TPRINTF(".");
@@ -825 +849 @@
         size_t reader_cnt = thread_cnt;
         size_t updater_cnt = thread_cnt;
-
-        TPRINTF("\nStress: Run %zu nop-readers and %zu updaters. %zu cbs/updater. "
-                "Be very patient.\n", reader_cnt, updater_cnt, cb_per_thread);
+        
+        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;
+        bin_order_suffix(max_used_mem, &mem_units, &mem_suffix, false);
+
+        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);
         
         for (size_t k = 0; k < reader_cnt; ++k) {
@@ -872 +904 @@
                 _rcu_call(e->expedite, &e->r, expedite_cb);
         } else {
+                /* Do not touch any of e's mem after we declare we're done with it. */
                 memory_barrier();
                 e->count_down = 0;
@@ -937 +970 @@
                         TPRINTF("\nSubtest %s() skipped.\n", test_func[i].desc);
                         continue;
+                } else {
+                        TPRINTF("\nRunning subtest %s.\n", test_func[i].desc);
                 }