Fix: change method used by _rcu_dereference to strip type constness
[urcu.git] / tests / benchmark / test_urcu_hash_unique.c
CommitLineData
20adf780
MD
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
20adf780
MD
23#include "test_urcu_hash.h"
24
25enum urcu_hash_addremove {
26 AR_RANDOM = 0,
27 AR_ADD = 1,
28 AR_REMOVE = -1,
29}; /* 1: add, -1 remove, 0: random */
30
31static enum urcu_hash_addremove addremove; /* 1: add, -1 remove, 0: random */
32
70469b43 33void test_hash_unique_sigusr1_handler(int signo __attribute__((unused)))
20adf780
MD
34{
35 switch (addremove) {
36 case AR_ADD:
37 printf("Add/Remove: random.\n");
38 addremove = AR_RANDOM;
39 break;
40 case AR_RANDOM:
41 printf("Add/Remove: remove only.\n");
42 addremove = AR_REMOVE;
43 break;
44 case AR_REMOVE:
45 printf("Add/Remove: add only.\n");
46 addremove = AR_ADD;
47 break;
48 }
49}
50
70469b43 51void test_hash_unique_sigusr2_handler(int signo __attribute__((unused)))
20adf780
MD
52{
53 char msg[1] = { 0x42 };
54 ssize_t ret;
55
56 do {
57 ret = write(count_pipe[1], msg, 1); /* wakeup thread */
58 } while (ret == -1L && errno == EINTR);
59}
60
61void *test_hash_unique_thr_reader(void *_count)
62{
63 unsigned long long *count = _count;
64
94df6318
MD
65 printf_verbose("thread_begin %s, tid %lu\n",
66 "reader", urcu_get_thread_id());
20adf780 67
98f483d2
MD
68 URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
69
20adf780
MD
70 set_affinity();
71
72 rcu_register_thread();
73
74 while (!test_go)
75 {
76 }
77 cmm_smp_mb();
78
79 for (;;) {
80 struct lfht_test_node *node;
81 struct cds_lfht_iter iter;
82 /*
83 * iterate on whole table, ensuring that no duplicate is
84 * found.
85 */
86 rcu_read_lock();
87 cds_lfht_for_each_entry(test_ht, &iter, node, node) {
88 struct cds_lfht_iter dup_iter;
89
90 dup_iter = iter;
91 cds_lfht_next_duplicate(test_ht, test_match,
92 node->key, &dup_iter);
93 if (dup_iter.node != NULL) {
94 printf("[ERROR] Duplicate key %p found\n", node->key);
95 }
96 }
97 rcu_read_unlock();
98
1de4df4b 99 rcu_debug_yield_read();
20adf780
MD
100 if (caa_unlikely(rduration))
101 loop_sleep(rduration);
bd252a04 102 URCU_TLS(nr_reads)++;
20adf780
MD
103 if (caa_unlikely(!test_duration_read()))
104 break;
bd252a04 105 if (caa_unlikely((URCU_TLS(nr_reads) & ((1 << 10) - 1)) == 0))
20adf780
MD
106 rcu_quiescent_state();
107 }
108
109 rcu_unregister_thread();
110
bd252a04 111 *count = URCU_TLS(nr_reads);
94df6318
MD
112 printf_verbose("thread_end %s, tid %lu\n",
113 "reader", urcu_get_thread_id());
114 printf_verbose("read tid : %lu, lookupfail %lu, lookupok %lu\n",
115 urcu_get_thread_id(), URCU_TLS(lookup_fail),
bd252a04 116 URCU_TLS(lookup_ok));
20adf780
MD
117 return ((void*)1);
118
119}
120
121void *test_hash_unique_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 int loc_add_unique;
129
94df6318
MD
130 printf_verbose("thread_begin %s, tid %lu\n",
131 "writer", urcu_get_thread_id());
20adf780 132
98f483d2
MD
133 URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
134
20adf780
MD
135 set_affinity();
136
137 rcu_register_thread();
138
139 while (!test_go)
140 {
141 }
142 cmm_smp_mb();
143
144 for (;;) {
145 /*
146 * add unique/add replace with new node key from range.
147 */
148 if (1 || (addremove == AR_ADD || add_only)
bd252a04 149 || (addremove == AR_RANDOM && rand_r(&URCU_TLS(rand_lookup)) & 1)) {
20adf780
MD
150 node = malloc(sizeof(struct lfht_test_node));
151 lfht_test_node_init(node,
bd252a04 152 (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
20adf780
MD
153 sizeof(void *));
154 rcu_read_lock();
bd252a04 155 loc_add_unique = rand_r(&URCU_TLS(rand_lookup)) & 1;
20adf780
MD
156 if (loc_add_unique) {
157 ret_node = cds_lfht_add_unique(test_ht,
158 test_hash(node->key, node->key_len, TEST_HASH_SEED),
159 test_match, node->key, &node->node);
160 } else {
161 ret_node = cds_lfht_add_replace(test_ht,
162 test_hash(node->key, node->key_len, TEST_HASH_SEED),
163 test_match, node->key, &node->node);
164#if 0 //generate an error on purpose
165 cds_lfht_add(test_ht,
166 test_hash(node->key, node->key_len, TEST_HASH_SEED),
167 &node->node);
168 ret_node = NULL;
169#endif //0
170 }
171 rcu_read_unlock();
172 if (loc_add_unique) {
173 if (ret_node != &node->node) {
174 free(node);
bd252a04 175 URCU_TLS(nr_addexist)++;
20adf780 176 } else {
bd252a04 177 URCU_TLS(nr_add)++;
20adf780
MD
178 }
179 } else {
180 if (ret_node) {
181 call_rcu(&to_test_node(ret_node)->head,
182 free_node_cb);
bd252a04 183 URCU_TLS(nr_addexist)++;
20adf780 184 } else {
bd252a04 185 URCU_TLS(nr_add)++;
20adf780
MD
186 }
187 }
188 } else {
189 /* May delete */
190 rcu_read_lock();
191 cds_lfht_test_lookup(test_ht,
bd252a04 192 (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
20adf780
MD
193 sizeof(void *), &iter);
194 ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
195 rcu_read_unlock();
196 if (ret == 0) {
197 node = cds_lfht_iter_get_test_node(&iter);
198 call_rcu(&node->head, free_node_cb);
bd252a04 199 URCU_TLS(nr_del)++;
20adf780 200 } else
bd252a04 201 URCU_TLS(nr_delnoent)++;
20adf780
MD
202 }
203#if 0
bd252a04
MD
204 //if (URCU_TLS(nr_writes) % 100000 == 0) {
205 if (URCU_TLS(nr_writes) % 1000 == 0) {
20adf780 206 rcu_read_lock();
bd252a04 207 if (rand_r(&URCU_TLS(rand_lookup)) & 1) {
20adf780
MD
208 ht_resize(test_ht, 1);
209 } else {
210 ht_resize(test_ht, -1);
211 }
212 rcu_read_unlock();
213 }
214#endif //0
bd252a04 215 URCU_TLS(nr_writes)++;
20adf780
MD
216 if (caa_unlikely(!test_duration_write()))
217 break;
218 if (caa_unlikely(wdelay))
219 loop_sleep(wdelay);
bd252a04 220 if (caa_unlikely((URCU_TLS(nr_writes) & ((1 << 10) - 1)) == 0))
20adf780
MD
221 rcu_quiescent_state();
222 }
223
224 rcu_unregister_thread();
225
94df6318
MD
226 printf_verbose("thread_end %s, tid %lu\n",
227 "writer", urcu_get_thread_id());
228 printf_verbose("info tid %lu: nr_add %lu, nr_addexist %lu, nr_del %lu, "
229 "nr_delnoent %lu\n", urcu_get_thread_id(),
230 URCU_TLS(nr_add),
231 URCU_TLS(nr_addexist),
232 URCU_TLS(nr_del),
bd252a04
MD
233 URCU_TLS(nr_delnoent));
234 count->update_ops = URCU_TLS(nr_writes);
235 count->add = URCU_TLS(nr_add);
236 count->add_exist = URCU_TLS(nr_addexist);
237 count->remove = URCU_TLS(nr_del);
20adf780
MD
238 return ((void*)2);
239}
240
241int test_hash_unique_populate_hash(void)
242{
243 struct lfht_test_node *node;
244 struct cds_lfht_node *ret_node;
245
246 printf("Starting uniqueness test.\n");
247
98f483d2
MD
248 URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
249
20adf780
MD
250 if (!init_populate)
251 return 0;
252
253 if (init_populate * 10 > init_pool_size) {
254 printf("WARNING: required to populate %lu nodes (-k), but random "
255"pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
256"larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
257 }
258
bd252a04 259 while (URCU_TLS(nr_add) < init_populate) {
20adf780
MD
260 node = malloc(sizeof(struct lfht_test_node));
261 lfht_test_node_init(node,
bd252a04 262 (void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % init_pool_size) + init_pool_offset),
20adf780
MD
263 sizeof(void *));
264 rcu_read_lock();
265 ret_node = cds_lfht_add_replace(test_ht,
266 test_hash(node->key, node->key_len, TEST_HASH_SEED),
267 test_match, node->key, &node->node);
268 rcu_read_unlock();
269 if (ret_node) {
270 call_rcu(&to_test_node(ret_node)->head, free_node_cb);
bd252a04 271 URCU_TLS(nr_addexist)++;
20adf780 272 } else {
bd252a04 273 URCU_TLS(nr_add)++;
20adf780 274 }
bd252a04 275 URCU_TLS(nr_writes)++;
20adf780
MD
276 }
277 return 0;
278}
This page took 0.05416 seconds and 4 git commands to generate.