rcuja test: cleanup

[userspace-rcu.git] / tests / test_urcu_ja.c

diff --git a/tests/test_urcu_ja.c b/tests/test_urcu_ja.c
index 2832650435378569b99ac09254a29e25f24f33f3..8e14a9b2c05216d17509897a40e140bd9dc13732 100644 (file)
--- a/tests/test_urcu_ja.c
+++ b/tests/test_urcu_ja.c
@@ -78,6 +78,9 @@ static int add_unique, add_replace;
 
 static pthread_mutex_t rcu_copy_mutex = PTHREAD_MUTEX_INITIALIZER;
 
+static int leak_detection;
+static unsigned long test_nodes_allocated, test_nodes_freed;
+
 void set_affinity(void)
 {
        cpu_set_t mask;
@@ -130,11 +133,25 @@ void rcu_copy_mutex_unlock(void)
        }
 }
 
+static
+struct ja_test_node *node_alloc(void)
+{
+       struct ja_test_node *node;
+
+       node = calloc(sizeof(*node), 1);
+       if (leak_detection && node)
+               uatomic_inc(&test_nodes_allocated);
+       return node;
+}
+
+static
 void free_node_cb(struct rcu_head *head)
 {
        struct ja_test_node *node =
                caa_container_of(head, struct ja_test_node, node.head);
        poison_free(node);
+       if (leak_detection)
+               uatomic_inc(&test_nodes_freed);
 }
 
 #if 0
@@ -182,6 +199,7 @@ printf("        [not -u nor -s] Add entries (supports redundant keys).\n");
        printf("        [-t] Do sanity test.\n");
        printf("        [-B] Key bits for multithread test (default: 32).\n");
        printf("        [-m factor] Key multiplication factor.\n");
+       printf("        [-l] Memory leak detection.\n");
        printf("\n\n");
 }
 
@@ -202,8 +220,7 @@ int test_8bit_key(void)
        /* Add keys */
        printf("Test #1: add keys (8-bit).\n");
        for (key = 0; key < 200; key++) {
-               struct ja_test_node *node =
-                       calloc(sizeof(*node), 1);
+               struct ja_test_node *node = node_alloc();
 
                ja_test_node_init(node, key);
                rcu_read_lock();
@@ -297,8 +314,7 @@ int test_16bit_key(void)
        printf("Test #1: add keys (16-bit).\n");
        for (key = 0; key < 10000; key++) {
        //for (key = 0; key < 65536; key+=256) {
-               struct ja_test_node *node =
-                       calloc(sizeof(*node), 1);
+               struct ja_test_node *node = node_alloc();
 
                ja_test_node_init(node, key);
                rcu_read_lock();
@@ -404,8 +420,7 @@ int test_sparse_key(unsigned int bits, int nr_dup)
        for (i = 0; i < nr_dup; i++) {
                zerocount = 0;
                for (key = 0; key <= max_key && (key != 0 || zerocount < 1); key += 1ULL << (bits - 8)) {
-                       struct ja_test_node *node =
-                               calloc(sizeof(*node), 1);
+                       struct ja_test_node *node = node_alloc();
 
                        ja_test_node_init(node, key);
                        rcu_read_lock();
@@ -669,7 +684,7 @@ void *test_ja_rw_thr_writer(void *_count)
        for (;;) {
                if ((addremove == AR_ADD)
                                || (addremove == AR_RANDOM && is_add())) {
-                       struct ja_test_node *node = malloc(sizeof(*node));
+                       struct ja_test_node *node = node_alloc();
                        struct cds_ja_node *ret_node;
 
                        /* note: only inserting ulong keys */
@@ -760,7 +775,7 @@ int do_mt_populate_ja(void)
        printf("Starting rw test\n");
 
        for (iter = init_pool_offset; iter < init_pool_offset + init_pool_size; iter++) {
-               struct ja_test_node *node = malloc(sizeof(*node));
+               struct ja_test_node *node = node_alloc();
                uint64_t key;
 
                /* note: only inserting ulong keys */
@@ -870,6 +885,21 @@ end:
        return ret;
 }
 
+static
+int check_memory_leaks(void)
+{
+       unsigned long na, nf;
+
+       na = uatomic_read(&test_nodes_allocated);
+       nf = uatomic_read(&test_nodes_freed);
+       if (na != nf) {
+               fprintf(stderr, "Memory leak of %ld test nodes detected. Allocated: %lu, freed: %lu\n",
+                       na - nf, na, nf);
+               return -1;
+       }
+       return 0;
+}
+
 int main(int argc, char **argv)
 {
        int i, j, a, ret, err;
@@ -980,6 +1010,9 @@ int main(int argc, char **argv)
                case 's':
                        add_replace = 1;
                        break;
+               case 'l':
+                       leak_detection = 1;
+                       break;
                }
        }
 
@@ -1000,6 +1033,8 @@ int main(int argc, char **argv)
                write_pool_offset, write_pool_size);
        if (validate_lookup)
                printf_verbose("Validating lookups.\n");
+       if (leak_detection)
+               printf_verbose("Memory leak dection activated.\n");
        printf_verbose("thread %-6s, thread id : %lx, tid %lu\n",
                        "main", pthread_self(), (unsigned long)gettid());
 
@@ -1030,6 +1065,11 @@ int main(int argc, char **argv)
                ret = do_mt_test();
        }
 
+       /* Wait for in-flight call_rcu free to complete for leak detection */
+       rcu_barrier();
+
+       ret |= check_memory_leaks();
+
        rcu_unregister_thread();
        free_all_cpu_call_rcu_data();
 
@@ -1037,69 +1077,4 @@ int main(int argc, char **argv)
                printf("Test ended with error: %d\n", ret);
        }
        return ret;
-
-#if 0
-       /*
-        * Hash Population needs to be seen as a RCU reader
-        * thread from the point of view of resize.
-        */
-       rcu_register_thread();
-       ret = (get_populate_hash_cb())();
-       assert(!ret);
-
-       rcu_thread_offline();
-
-       /* teardown counter thread */
-       act.sa_handler = SIG_IGN;
-       act.sa_flags = SA_RESTART;
-       ret = sigaction(SIGUSR2, &act, NULL);
-       if (ret == -1) {
-               perror("sigaction");
-               return -1;
-       }
-       {
-               char msg[1] = { 0x42 };
-               ssize_t ret;
-
-               do {
-                       ret = write(count_pipe[1], msg, 1);     /* wakeup thread */
-               } while (ret == -1L && errno == EINTR);
-       }
-
-       fflush(stdout);
-       rcu_thread_online();
-       rcu_read_lock();
-       printf("Counting nodes... ");
-       cds_lfht_count_nodes(test_ht, &approx_before, &count, &approx_after);
-       printf("done.\n");
-       test_delete_all_nodes(test_ht);
-       rcu_read_unlock();
-       rcu_thread_offline();
-       if (count) {
-               printf("Approximation before node accounting: %ld nodes.\n",
-                       approx_before);
-               printf("Nodes deleted from hash table before destroy: "
-                       "%lu nodes.\n",
-                       count);
-               printf("Approximation after node accounting: %ld nodes.\n",
-                       approx_after);
-       }
-       ret = cds_lfht_destroy(test_ht, NULL);
-       if (ret)
-               printf_verbose("final delete aborted\n");
-       else
-               printf_verbose("final delete success\n");
-       printf_verbose("total number of reads : %llu, writes %llu\n", tot_reads,
-              tot_writes);
-       printf("SUMMARY %-25s testdur %4lu nr_readers %3u rdur %6lu "
-               "nr_writers %3u "
-               "wdelay %6lu nr_reads %12llu nr_writes %12llu nr_ops %12llu "
-               "nr_add %12llu nr_add_fail %12llu nr_remove %12llu nr_leaked %12lld\n",
-               argv[0], duration, nr_readers, rduration,
-               nr_writers, wdelay, tot_reads, tot_writes,
-               tot_reads + tot_writes, tot_add, tot_add_exist, tot_remove,
-               (long long) tot_add + init_populate - tot_remove - count);
-       rcu_unregister_thread();
-#endif
-       return 0;
 }