tests/test_urcu_hash_unique.c

   1 /*
   2  * test_urcu_hash_unique.c
   3  *
   4  * Userspace RCU library - test program
   5  *
   6  * Copyright 2009-2012 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include "test_urcu_hash.h"
  25
  26 enum urcu_hash_addremove {
  27         AR_RANDOM = 0,
  28         AR_ADD = 1,
  29         AR_REMOVE = -1,
  30 };      /* 1: add, -1 remove, 0: random */
  31
  32 static enum urcu_hash_addremove addremove; /* 1: add, -1 remove, 0: random */
  33
  34 void test_hash_unique_sigusr1_handler(int signo)
  35 {
  36         switch (addremove) {
  37         case AR_ADD:
  38                 printf("Add/Remove: random.\n");
  39                 addremove = AR_RANDOM;
  40                 break;
  41         case AR_RANDOM:
  42                 printf("Add/Remove: remove only.\n");
  43                 addremove = AR_REMOVE;
  44                 break;
  45         case AR_REMOVE:
  46                 printf("Add/Remove: add only.\n");
  47                 addremove = AR_ADD;
  48                 break;
  49         }
  50 }
  51
  52 void test_hash_unique_sigusr2_handler(int signo)
  53 {
  54         char msg[1] = { 0x42 };
  55         ssize_t ret;
  56
  57         do {
  58                 ret = write(count_pipe[1], msg, 1);     /* wakeup thread */
  59         } while (ret == -1L && errno == EINTR);
  60 }
  61
  62 void *test_hash_unique_thr_reader(void *_count)
  63 {
  64         unsigned long long *count = _count;
  65
  66         printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
  67                         "reader", pthread_self(), (unsigned long)gettid());
  68
  69         set_affinity();
  70
  71         rcu_register_thread();
  72
  73         while (!test_go)
  74         {
  75         }
  76         cmm_smp_mb();
  77
  78         for (;;) {
  79                 struct lfht_test_node *node;
  80                 struct cds_lfht_iter iter;
  81                 /*
  82                  * iterate on whole table, ensuring that no duplicate is
  83                  * found.
  84                  */
  85                 rcu_read_lock();
  86                 cds_lfht_for_each_entry(test_ht, &iter, node, node) {
  87                         struct cds_lfht_iter dup_iter;
  88
  89                         dup_iter = iter;
  90                         cds_lfht_next_duplicate(test_ht, test_match,
  91                                 node->key, &dup_iter);
  92                         if (dup_iter.node != NULL) {
  93                                 printf("[ERROR] Duplicate key %p found\n", node->key);
  94                         }
  95                 }
  96                 rcu_read_unlock();
  97
  98                 debug_yield_read();
  99                 if (caa_unlikely(rduration))
 100                         loop_sleep(rduration);
 101                 nr_reads++;
 102                 if (caa_unlikely(!test_duration_read()))
 103                         break;
 104                 if (caa_unlikely((nr_reads & ((1 << 10) - 1)) == 0))
 105                         rcu_quiescent_state();
 106         }
 107
 108         rcu_unregister_thread();
 109
 110         *count = nr_reads;
 111         printf_verbose("thread_end %s, thread id : %lx, tid %lu\n",
 112                         "reader", pthread_self(), (unsigned long)gettid());
 113         printf_verbose("readid : %lx, lookupfail %lu, lookupok %lu\n",
 114                         pthread_self(), lookup_fail, lookup_ok);
 115         return ((void*)1);
 116
 117 }
 118
 119 void *test_hash_unique_thr_writer(void *_count)
 120 {
 121         struct lfht_test_node *node;
 122         struct cds_lfht_node *ret_node;
 123         struct cds_lfht_iter iter;
 124         struct wr_count *count = _count;
 125         int ret;
 126         int loc_add_unique;
 127
 128         printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
 129                         "writer", pthread_self(), (unsigned long)gettid());
 130
 131         set_affinity();
 132
 133         rcu_register_thread();
 134
 135         while (!test_go)
 136         {
 137         }
 138         cmm_smp_mb();
 139
 140         for (;;) {
 141                 /*
 142                  * add unique/add replace with new node key from range.
 143                  */
 144                 if (1 || (addremove == AR_ADD || add_only)
 145                                 || (addremove == AR_RANDOM && rand_r(&rand_lookup) & 1)) {
 146                         node = malloc(sizeof(struct lfht_test_node));
 147                         lfht_test_node_init(node,
 148                                 (void *)(((unsigned long) rand_r(&rand_lookup) % write_pool_size) + write_pool_offset),
 149                                 sizeof(void *));
 150                         rcu_read_lock();
 151                         loc_add_unique = rand_r(&rand_lookup) & 1;
 152                         if (loc_add_unique) {
 153                                 ret_node = cds_lfht_add_unique(test_ht,
 154                                         test_hash(node->key, node->key_len, TEST_HASH_SEED),
 155                                         test_match, node->key, &node->node);
 156                         } else {
 157                                 ret_node = cds_lfht_add_replace(test_ht,
 158                                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 159                                                 test_match, node->key, &node->node);
 160 #if 0 //generate an error on purpose
 161                                 cds_lfht_add(test_ht,
 162                                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 163                                                 &node->node);
 164                                 ret_node = NULL;
 165 #endif //0
 166                         }
 167                         rcu_read_unlock();
 168                         if (loc_add_unique) {
 169                                 if (ret_node != &node->node) {
 170                                         free(node);
 171                                         nr_addexist++;
 172                                 } else {
 173                                         nr_add++;
 174                                 }
 175                         } else {
 176                                 if (ret_node) {
 177                                         call_rcu(&to_test_node(ret_node)->head,
 178                                                         free_node_cb);
 179                                         nr_addexist++;
 180                                 } else {
 181                                         nr_add++;
 182                                 }
 183                         }
 184                 } else {
 185                         /* May delete */
 186                         rcu_read_lock();
 187                         cds_lfht_test_lookup(test_ht,
 188                                 (void *)(((unsigned long) rand_r(&rand_lookup) % write_pool_size) + write_pool_offset),
 189                                 sizeof(void *), &iter);
 190                         ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
 191                         rcu_read_unlock();
 192                         if (ret == 0) {
 193                                 node = cds_lfht_iter_get_test_node(&iter);
 194                                 call_rcu(&node->head, free_node_cb);
 195                                 nr_del++;
 196                         } else
 197                                 nr_delnoent++;
 198                 }
 199 #if 0
 200                 //if (nr_writes % 100000 == 0) {
 201                 if (nr_writes % 1000 == 0) {
 202                         rcu_read_lock();
 203                         if (rand_r(&rand_lookup) & 1) {
 204                                 ht_resize(test_ht, 1);
 205                         } else {
 206                                 ht_resize(test_ht, -1);
 207                         }
 208                         rcu_read_unlock();
 209                 }
 210 #endif //0
 211                 nr_writes++;
 212                 if (caa_unlikely(!test_duration_write()))
 213                         break;
 214                 if (caa_unlikely(wdelay))
 215                         loop_sleep(wdelay);
 216                 if (caa_unlikely((nr_writes & ((1 << 10) - 1)) == 0))
 217                         rcu_quiescent_state();
 218         }
 219
 220         rcu_unregister_thread();
 221
 222         printf_verbose("thread_end %s, thread id : %lx, tid %lu\n",
 223                         "writer", pthread_self(), (unsigned long)gettid());
 224         printf_verbose("info id %lx: nr_add %lu, nr_addexist %lu, nr_del %lu, "
 225                         "nr_delnoent %lu\n", pthread_self(), nr_add,
 226                         nr_addexist, nr_del, nr_delnoent);
 227         count->update_ops = nr_writes;
 228         count->add = nr_add;
 229         count->add_exist = nr_addexist;
 230         count->remove = nr_del;
 231         return ((void*)2);
 232 }
 233
 234 int test_hash_unique_populate_hash(void)
 235 {
 236         struct lfht_test_node *node;
 237         struct cds_lfht_node *ret_node;
 238
 239         printf("Starting uniqueness test.\n");
 240
 241         if (!init_populate)
 242                 return 0;
 243
 244         if (init_populate * 10 > init_pool_size) {
 245                 printf("WARNING: required to populate %lu nodes (-k), but random "
 246 "pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
 247 "larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
 248         }
 249
 250         while (nr_add < init_populate) {
 251                 node = malloc(sizeof(struct lfht_test_node));
 252                 lfht_test_node_init(node,
 253                         (void *)(((unsigned long) rand_r(&rand_lookup) % init_pool_size) + init_pool_offset),
 254                         sizeof(void *));
 255                 rcu_read_lock();
 256                 ret_node = cds_lfht_add_replace(test_ht,
 257                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 258                                 test_match, node->key, &node->node);
 259                 rcu_read_unlock();
 260                 if (ret_node) {
 261                         call_rcu(&to_test_node(ret_node)->head, free_node_cb);
 262                         nr_addexist++;
 263                 } else {
 264                         nr_add++;
 265                 }
 266                 nr_writes++;
 267         }
 268         return 0;
 269 }