tests/benchmark/test_urcu_hash_rw.c

   1 /*
   2  * test_urcu_hash_rw.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_rw_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_rw_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_rw_thr_reader(void *_count)
  63 {
  64         unsigned long long *count = _count;
  65         struct lfht_test_node *node;
  66         struct cds_lfht_iter iter;
  67
  68         printf_verbose("thread_begin %s, tid %lu\n",
  69                         "reader", urcu_get_thread_id());
  70
  71         URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
  72
  73         set_affinity();
  74
  75         rcu_register_thread();
  76
  77         while (!test_go)
  78         {
  79         }
  80         cmm_smp_mb();
  81
  82         for (;;) {
  83                 rcu_read_lock();
  84                 cds_lfht_test_lookup(test_ht,
  85                         (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % lookup_pool_size) + lookup_pool_offset),
  86                         sizeof(void *), &iter);
  87                 node = cds_lfht_iter_get_test_node(&iter);
  88                 if (node == NULL) {
  89                         if (validate_lookup) {
  90                                 printf("[ERROR] Lookup cannot find initial node.\n");
  91                                 exit(-1);
  92                         }
  93                         URCU_TLS(lookup_fail)++;
  94                 } else {
  95                         URCU_TLS(lookup_ok)++;
  96                 }
  97                 rcu_debug_yield_read();
  98                 if (caa_unlikely(rduration))
  99                         loop_sleep(rduration);
 100                 rcu_read_unlock();
 101                 URCU_TLS(nr_reads)++;
 102                 if (caa_unlikely(!test_duration_read()))
 103                         break;
 104                 if (caa_unlikely((URCU_TLS(nr_reads) & ((1 << 10) - 1)) == 0))
 105                         rcu_quiescent_state();
 106         }
 107
 108         rcu_unregister_thread();
 109
 110         *count = URCU_TLS(nr_reads);
 111         printf_verbose("thread_end %s, tid %lu\n",
 112                         "reader", urcu_get_thread_id());
 113         printf_verbose("read tid : %lx, lookupfail %lu, lookupok %lu\n",
 114                         urcu_get_thread_id(),
 115                         URCU_TLS(lookup_fail),
 116                         URCU_TLS(lookup_ok));
 117         return ((void*)1);
 118
 119 }
 120
 121 void *test_hash_rw_thr_writer(void *_count)
 122 {
 123         struct lfht_test_node *node;
 124         struct cds_lfht_node *ret_node;
 125         struct cds_lfht_iter iter;
 126         struct wr_count *count = _count;
 127         int ret;
 128
 129         printf_verbose("thread_begin %s, tid %lu\n",
 130                         "writer", urcu_get_thread_id());
 131
 132         URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
 133
 134         set_affinity();
 135
 136         rcu_register_thread();
 137
 138         while (!test_go)
 139         {
 140         }
 141         cmm_smp_mb();
 142
 143         for (;;) {
 144                 if ((addremove == AR_ADD || add_only)
 145                                 || (addremove == AR_RANDOM && rand_r(&URCU_TLS(rand_lookup)) & 1)) {
 146                         node = malloc(sizeof(struct lfht_test_node));
 147                         lfht_test_node_init(node,
 148                                 (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
 149                                 sizeof(void *));
 150                         rcu_read_lock();
 151                         if (add_unique) {
 152                                 ret_node = cds_lfht_add_unique(test_ht,
 153                                         test_hash(node->key, node->key_len, TEST_HASH_SEED),
 154                                         test_match, node->key, &node->node);
 155                         } else {
 156                                 if (add_replace)
 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                                 else
 161                                         cds_lfht_add(test_ht,
 162                                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 163                                                 &node->node);
 164                         }
 165                         rcu_read_unlock();
 166                         if (add_unique && ret_node != &node->node) {
 167                                 free(node);
 168                                 URCU_TLS(nr_addexist)++;
 169                         } else {
 170                                 if (add_replace && ret_node) {
 171                                         call_rcu(&to_test_node(ret_node)->head,
 172                                                         free_node_cb);
 173                                         URCU_TLS(nr_addexist)++;
 174                                 } else {
 175                                         URCU_TLS(nr_add)++;
 176                                 }
 177                         }
 178                 } else {
 179                         /* May delete */
 180                         rcu_read_lock();
 181                         cds_lfht_test_lookup(test_ht,
 182                                 (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
 183                                 sizeof(void *), &iter);
 184                         ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
 185                         rcu_read_unlock();
 186                         if (ret == 0) {
 187                                 node = cds_lfht_iter_get_test_node(&iter);
 188                                 call_rcu(&node->head, free_node_cb);
 189                                 URCU_TLS(nr_del)++;
 190                         } else
 191                                 URCU_TLS(nr_delnoent)++;
 192                 }
 193 #if 0
 194                 //if (URCU_TLS(nr_writes) % 100000 == 0) {
 195                 if (URCU_TLS(nr_writes) % 1000 == 0) {
 196                         rcu_read_lock();
 197                         if (rand_r(&URCU_TLS(rand_lookup)) & 1) {
 198                                 ht_resize(test_ht, 1);
 199                         } else {
 200                                 ht_resize(test_ht, -1);
 201                         }
 202                         rcu_read_unlock();
 203                 }
 204 #endif //0
 205                 URCU_TLS(nr_writes)++;
 206                 if (caa_unlikely(!test_duration_write()))
 207                         break;
 208                 if (caa_unlikely(wdelay))
 209                         loop_sleep(wdelay);
 210                 if (caa_unlikely((URCU_TLS(nr_writes) & ((1 << 10) - 1)) == 0))
 211                         rcu_quiescent_state();
 212         }
 213
 214         rcu_unregister_thread();
 215
 216         printf_verbose("thread_end %s, tid %lu\n",
 217                         "writer", urcu_get_thread_id());
 218         printf_verbose("info tid %lu: nr_add %lu, nr_addexist %lu, nr_del %lu, "
 219                         "nr_delnoent %lu\n", urcu_get_thread_id(),
 220                         URCU_TLS(nr_add),
 221                         URCU_TLS(nr_addexist),
 222                         URCU_TLS(nr_del),
 223                         URCU_TLS(nr_delnoent));
 224         count->update_ops = URCU_TLS(nr_writes);
 225         count->add = URCU_TLS(nr_add);
 226         count->add_exist = URCU_TLS(nr_addexist);
 227         count->remove = URCU_TLS(nr_del);
 228         return ((void*)2);
 229 }
 230
 231 int test_hash_rw_populate_hash(void)
 232 {
 233         struct lfht_test_node *node;
 234         struct cds_lfht_node *ret_node;
 235
 236         if (!init_populate)
 237                 return 0;
 238
 239         printf("Starting rw test\n");
 240
 241         URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
 242
 243         if ((add_unique || add_replace) && init_populate * 10 > init_pool_size) {
 244                 printf("WARNING: required to populate %lu nodes (-k), but random "
 245 "pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
 246 "larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
 247         }
 248
 249         while (URCU_TLS(nr_add) < init_populate) {
 250                 node = malloc(sizeof(struct lfht_test_node));
 251                 lfht_test_node_init(node,
 252                         (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % init_pool_size) + init_pool_offset),
 253                         sizeof(void *));
 254                 rcu_read_lock();
 255                 if (add_unique) {
 256                         ret_node = cds_lfht_add_unique(test_ht,
 257                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 258                                 test_match, node->key, &node->node);
 259                 } else {
 260                         if (add_replace)
 261                                 ret_node = cds_lfht_add_replace(test_ht,
 262                                                 test_hash(node->key, node->key_len, TEST_HASH_SEED),
 263                                                 test_match, node->key, &node->node);
 264                         else
 265                                 cds_lfht_add(test_ht,
 266                                         test_hash(node->key, node->key_len, TEST_HASH_SEED),
 267                                         &node->node);
 268                 }
 269                 rcu_read_unlock();
 270                 if (add_unique && ret_node != &node->node) {
 271                         free(node);
 272                         URCU_TLS(nr_addexist)++;
 273                 } else {
 274                         if (add_replace && ret_node) {
 275                                 call_rcu(&to_test_node(ret_node)->head, free_node_cb);
 276                                 URCU_TLS(nr_addexist)++;
 277                         } else {
 278                                 URCU_TLS(nr_add)++;
 279                         }
 280                 }
 281                 URCU_TLS(nr_writes)++;
 282         }
 283         return 0;
 284 }