Change the traversal to use ao2_callback() instead of an ao2_iterator. Using
[asterisk/asterisk.git] / utils / hashtest2.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007, Steve Murphy
5  *
6  * Steve Murphy <murf@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18 /*! \file
19  *
20  *  \brief A program to thoroughly thrash a hash table, testing
21  *         out locking safety, and making sure all functionality
22  *         is functioning. Run with 5 or more threads to get that
23  *         fully intense firestorm of activity. If your
24  *         hash tables don't crash, lock up, or go weird, it must
25  *         be good code! Even features some global counters
26  *         that will get slightly behind because they aren't lock-protected.
27  *
28  *  \author Steve Murphy <murf@digium.com>
29  */
30
31 #include "asterisk.h"
32
33 #include <sys/types.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <stdarg.h>
37 #ifdef HAVE_ALLOCA_H
38 #include <alloca.h>
39 #endif
40 #include <string.h>
41 #include <pthread.h>
42 #include <sys/stat.h>
43 #include <signal.h>
44 #include <errno.h>
45 #include <unistd.h>
46
47 #include "asterisk/compat.h"
48 #include "asterisk/lock.h"
49 #include "asterisk/astobj2.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/utils.h"
52 #include "asterisk/module.h"
53
54 int testno = 2;
55
56 /* stuff we need to make this work with the astobj2 stuff */
57
58 void ast_cli(int *fd, char *str, ...)
59 {
60 }
61
62 int64_t ast_mark(int prof_id, int x)
63 {
64 }
65
66 /* my OBJECT */
67 struct ht_element 
68 {
69         char *key;
70         char *val;
71 };
72
73
74 static int hash_string(const void *obj, const int flags)
75 {
76         unsigned char *str = ((struct ht_element*)obj)->key;
77         int total;
78
79         for (total=0; *str; str++)
80         {
81                 unsigned int tmp = total;
82                 total <<= 1; /* multiply by 2 */
83                 total += tmp; /* multiply by 3 */
84                 total <<= 2; /* multiply by 12 */
85                 total += tmp; /* multiply by 13 */
86         
87                 total += ((unsigned int)(*str));
88         }
89         if (total < 0)
90                 total = -total;
91         return total;
92 }
93
94 static int hashtab_compare_strings(void *a, void *b, int flags)
95 {
96         const struct ht_element *ae = a, *be = b;
97         return !strcmp(ae->key, be->key) ? CMP_MATCH : 0;
98 }
99
100 /* random numbers */
101
102 my_rand(int incl_low, int incl_high, unsigned int *seedp)
103 {
104         if (incl_high == 0)
105                 return 0;
106         
107         return incl_low + (rand_r(seedp) % incl_high);
108 }
109
110
111
112
113 /* the testing routines */
114
115 static int glob_highwater = 0;
116 struct ao2_container *glob_hashtab = 0;
117 unsigned int glob_seed = 0;
118 int els_removed = 0;
119 int els_added = 0;
120 int els_lookedup = 0;
121 int els_found = 0;
122 int els_traversals = 0;
123
124 /* all the operations to perform on the hashtab */
125
126 void ht_destroy(void *obj)
127 {
128         const struct ht_element *o = obj;
129         if (o->key)
130                 free(o->key);
131         if (o->val)
132                 free(o->val);
133 }
134
135
136 static void add_element(void)
137 {
138         char keybuf[100];
139         struct ht_element *x = ao2_alloc(sizeof(struct ht_element), ht_destroy);
140         sprintf(keybuf,"key%08d", glob_highwater++);
141         x->key = strdup(keybuf);
142         x->val = strdup("interesting data");
143 #ifdef DEBUG
144         printf("+ %s\n", keybuf);
145 #endif  
146         ao2_link(glob_hashtab, x);
147         
148         els_added++; /* unprotected, sometimes off, but, not really important, either */
149 }
150
151 static int do_nothing_cb(void *obj, void *arg, int flags)
152 {
153         return 0;
154 }
155
156 static void traverse_elements(void)
157 {
158 #ifdef DEBUG
159         printf("Traverse hashtab\n");
160 #endif
161         ao2_callback(glob_hashtab, OBJ_NODATA, do_nothing_cb, NULL);
162         els_traversals++; /* unprotected, sometimes off, but, not really important, either */
163 }
164
165 static void * del_element(unsigned int *seedp)
166 {
167         char keybuf[100];
168         struct ht_element *el, lookup;
169         int x;
170         
171         /* pick a random element from 0 to highwater-1 */
172         x = my_rand(0,glob_highwater-1,seedp);
173         sprintf(keybuf, "key%08d", x);
174 #ifdef DEBUG
175         printf("- %s", keybuf);
176 #endif
177         lookup.key = keybuf;
178         el = ao2_find(glob_hashtab, &lookup, OBJ_POINTER);
179         if (el) {
180 #ifdef DEBUG
181                 printf("...YES (el=%x)\n", (unsigned long)el);
182 #endif
183                 ao2_unlink(glob_hashtab, el); /* mistakenly tried to use ao2_ref(c,-2) here to unlink. Bad Boy! */
184                 els_removed++;
185         } else {
186 #ifdef DEBUG
187                 printf("...NO.\n");
188 #endif
189                 return 0;
190         }
191         return el;
192 }
193
194 static int lookup_element(unsigned int *seedp)
195 {
196         char keybuf[100];
197         struct ht_element *el, lookup;
198         int x;
199         
200         /* pick a random element from 0 to highwater-1 */
201         x = my_rand(0,glob_highwater-1,seedp);
202         sprintf(keybuf, "key%08d", x);
203         lookup.key = keybuf;
204         el = ao2_find(glob_hashtab, &lookup, OBJ_POINTER);
205         els_lookedup++;
206         if (el) {
207                 els_found++;
208                 ao2_ref(el, -1); /* toss out this ref, no longer needed */
209                 return 1;
210         } else {
211                 return 0;
212         }
213 }
214
215
216 static void *hashtest(void *data)
217 {
218         int my_els_removed = 0;
219         int my_els_added = 0;
220         int my_els_lookedup = 0;
221         int my_els_found = 0;
222         int my_els_traversals = 0;
223         int my_testno = testno++;
224         
225         /* data will be a random number == use as a seed for random numbers */
226         unsigned long seed = (unsigned long)data;
227         printf("hashtest thread created... test beginning\n");
228         
229         /* main test routine-- a global hashtab exists, pound it like crazy  */
230         int its;
231         for(its=0;its<100000;its++)
232         {
233                 void *seed2 = &seed;
234                 int op = my_rand(0,100, seed2);
235                 if (op<60) {
236                         my_els_lookedup++;
237 #ifdef DEBUG
238                         printf("%d[%d]: LOOKUP\n", my_testno, its);
239 #endif                  
240                         if ((my_els_lookedup%1000)==0) {
241                                 printf(".");
242                                 fflush(stdout);
243                         }
244                         if (lookup_element(seed2))
245                                 my_els_found++;
246                 } else if (op < 61) { /* make this 61 and it'll take 16 minutes to run */
247 #ifdef DEBUG
248                         printf("%d[%d]: TRAVERSE\n", my_testno, its);
249 #endif
250                         traverse_elements();
251                         my_els_traversals++;
252                         
253                 } else if (op < 80) {
254 #ifdef DEBUG
255                         printf("%d[%d]: REMOVE\n", my_testno, its);
256 #endif
257                         if (del_element(seed2))
258                                 my_els_removed++;
259                 } else {
260                         my_els_added++;
261 #ifdef DEBUG
262                         printf("%d[%d]: ADD\n", my_testno, its);
263 #endif
264                         add_element();
265                 }
266         }
267         printf("\nhashtest thread %d exiting.... lookups=%d/%d, added=%d, removed=%d, traversals=%d;\n",
268                    my_testno, my_els_found, my_els_lookedup, my_els_added, my_els_removed, my_els_traversals);
269         printf("\ntotals..................... lookups=%d/%d, added=%d, removed=%d; traversals=%d\n",
270                    els_found, els_lookedup, els_added, els_removed, els_traversals);
271         pthread_exit(0);
272 }
273
274 void run_hashtest(int numthr)
275 {
276         pthread_t thr[numthr];
277         void *thrres[numthr];
278         int i;
279         
280         /* init a single global hashtab, then... */
281         glob_hashtab = ao2_container_alloc(180000, hash_string, hashtab_compare_strings);
282
283         /* set a random seed  */
284         glob_seed = (unsigned int)time(0);
285         srand(glob_seed);
286         
287         /* create threads, each running hashtest */
288         for(i=0;i<numthr;i++)
289         {
290                 unsigned long z = rand();
291                 
292                 printf("starting hashtest thread %d....\n",i+1);
293                 if (ast_pthread_create(&thr[i], NULL, hashtest, (void*)z)) {
294                         printf("Sorry, couldn't create thread #%d\n", i+1);
295                 }
296                 printf("hashtest thread spawned.... \n");
297         }
298         /* collect threads, each running hashtest */
299         for(i=0;i<numthr;i++)
300         {
301                 printf("waiting for thread %d....\n", i+1);
302                 if (pthread_join(thr[i], &thrres[i])) {
303                         printf("Sorry, couldn't join thread #%d\n", i+1);
304                 }
305                 printf("hashtest thread %d done.... \n",i+1);
306         }
307         /* user has to kill/intr the process to stop the test? */
308 }
309
310
311 int main(int argc,char **argv)
312 {
313         if (argc < 2 || argc > 2 || atoi(argv[1]) < 1)
314         {
315                 printf("Usage: hashtest <number of threads>\n");
316                 exit(1);
317         }
318         
319         /* one arg == number of threads to create */
320         run_hashtest(atoi(argv[1]));
321         
322         return 0;
323 }
324
325
326 struct ast_app *pbx_findapp(const char *app)
327 {
328         return (struct ast_app*)1; /* so as not to trigger an error */
329 }
330
331 int  ast_add_profile(const char *x, uint64_t scale)
332 {
333 }
334
335 int ast_loader_register(int (*updater)(void))
336 {
337         return 1;
338 }
339
340 int ast_loader_unregister(int (*updater)(void))
341 {
342         return 1;
343 }
344 void ast_module_register(const struct ast_module_info *x)
345 {
346 }
347
348 void ast_module_unregister(const struct ast_module_info *x)
349 {
350 }
351
352
353 void ast_cli_register_multiple(void)
354 {
355 }
356
357 void ast_register_file_version(const char *file, const char *version)
358 {
359 }
360
361 void ast_unregister_file_version(const char *file)
362 {
363
364 }
365
366 void ast_cli_unregister_multiple(void)
367 {
368 }
369
370 void ast_context_destroy(void)
371 {
372 }
373
374 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
375 {
376         va_list vars;
377         va_start(vars,fmt);
378         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
379                    level, file, line, function);
380         vprintf(fmt, vars);
381         fflush(stdout);
382         va_end(vars);
383 }
384
385 void ast_verbose(const char *fmt, ...)
386 {
387         va_list vars;
388         va_start(vars,fmt);
389
390         printf("VERBOSE: ");
391         vprintf(fmt, vars);
392         fflush(stdout);
393         va_end(vars);
394 }
395
396 void ast_register_thread(char *name)
397 {
398
399 }
400
401 void ast_unregister_thread(void *id)
402 {
403 }