Merged revisions 89536 via svnmerge from
[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 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include <pthread.h>
36 #include <sys/stat.h>
37 #include <signal.h>
38
39 #include "asterisk/lock.h"
40 #include "asterisk/astobj2.h"
41 #include "asterisk/channel.h"
42 #include "asterisk/utils.h"
43 #include "asterisk/module.h"
44
45 int testno = 2;
46
47 /* stuff we need to make this work with the astobj2 stuff */
48
49 int64_t ast_mark(int prof_id, int x)
50 {
51         return 0;
52 }
53
54 /* my OBJECT */
55 struct ht_element 
56 {
57         char *key;
58         char *val;
59 };
60
61
62 static int hash_string(const void *obj, const int flags)
63 {
64         char *str = ((struct ht_element*)obj)->key;
65         int total;
66
67         for (total=0; *str; str++)
68         {
69                 unsigned int tmp = total;
70                 total <<= 1; /* multiply by 2 */
71                 total += tmp; /* multiply by 3 */
72                 total <<= 2; /* multiply by 12 */
73                 total += tmp; /* multiply by 13 */
74         
75                 total += ((unsigned int)(*str));
76         }
77         if (total < 0)
78                 total = -total;
79         return total;
80 }
81
82 static int hashtab_compare_strings(void *a, void *b, int flags)
83 {
84         const struct ht_element *ae = a, *be = b;
85         return !strcmp(ae->key, be->key) ? CMP_MATCH : 0;
86 }
87
88 /* random numbers */
89
90 static int my_rand(int incl_low, int incl_high, unsigned int *seedp)
91 {
92         if (incl_high == 0)
93                 return 0;
94         
95         return incl_low + (rand_r(seedp) % incl_high);
96 }
97
98
99
100
101 /* the testing routines */
102
103 static int glob_highwater = 0;
104 struct ao2_container *glob_hashtab = 0;
105 unsigned int glob_seed = 0;
106 int els_removed = 0;
107 int els_added = 0;
108 int els_lookedup = 0;
109 int els_found = 0;
110 int els_traversals = 0;
111
112 /* all the operations to perform on the hashtab */
113
114 static void ht_destroy(void *obj)
115 {
116         const struct ht_element *o = obj;
117         if (o->key)
118                 free(o->key);
119         if (o->val)
120                 free(o->val);
121 }
122
123
124 static void add_element(void)
125 {
126         char keybuf[100];
127         struct ht_element *x = ao2_alloc(sizeof(struct ht_element), ht_destroy);
128         sprintf(keybuf,"key%08d", glob_highwater++);
129         x->key = strdup(keybuf);
130         x->val = strdup("interesting data");
131 #ifdef DEBUG
132         printf("+ %s\n", keybuf);
133 #endif  
134         ao2_link(glob_hashtab, x);
135         
136         els_added++; /* unprotected, sometimes off, but, not really important, either */
137 }
138
139 static int do_nothing_cb(void *obj, void *arg, int flags)
140 {
141         return 0;
142 }
143
144 static void traverse_elements(void)
145 {
146 #ifdef DEBUG
147         printf("Traverse hashtab\n");
148 #endif
149         ao2_callback(glob_hashtab, OBJ_NODATA, do_nothing_cb, NULL);
150         els_traversals++; /* unprotected, sometimes off, but, not really important, either */
151 }
152
153 static void * del_element(unsigned int *seedp)
154 {
155         char keybuf[100];
156         struct ht_element *el, lookup;
157         int x;
158         
159         /* pick a random element from 0 to highwater-1 */
160         x = my_rand(0,glob_highwater-1,seedp);
161         sprintf(keybuf, "key%08d", x);
162 #ifdef DEBUG
163         printf("- %s", keybuf);
164 #endif
165         lookup.key = keybuf;
166         el = ao2_find(glob_hashtab, &lookup, OBJ_POINTER);
167         if (el) {
168 #ifdef DEBUG
169                 printf("...YES (el=%x)\n", (unsigned long)el);
170 #endif
171                 ao2_unlink(glob_hashtab, el); /* mistakenly tried to use ao2_ref(c,-2) here to unlink. Bad Boy! */
172                 els_removed++;
173         } else {
174 #ifdef DEBUG
175                 printf("...NO.\n");
176 #endif
177                 return 0;
178         }
179         return el;
180 }
181
182 static int lookup_element(unsigned int *seedp)
183 {
184         char keybuf[100];
185         struct ht_element *el, lookup;
186         int x;
187         
188         /* pick a random element from 0 to highwater-1 */
189         x = my_rand(0,glob_highwater-1,seedp);
190         sprintf(keybuf, "key%08d", x);
191         lookup.key = keybuf;
192         el = ao2_find(glob_hashtab, &lookup, OBJ_POINTER);
193         els_lookedup++;
194         if (el) {
195                 els_found++;
196                 ao2_ref(el, -1); /* toss out this ref, no longer needed */
197                 return 1;
198         } else {
199                 return 0;
200         }
201 }
202
203
204 static void *hashtest(void *data)
205 {
206         int my_els_removed = 0;
207         int my_els_added = 0;
208         int my_els_lookedup = 0;
209         int my_els_found = 0;
210         int my_els_traversals = 0;
211         int my_testno = testno++;
212         int its;
213         
214         /* data will be a random number == use as a seed for random numbers */
215         unsigned long seed = (unsigned long)data;
216         printf("hashtest thread created... test beginning\n");
217         
218         /* main test routine-- a global hashtab exists, pound it like crazy  */
219         for(its=0;its<100000;its++)
220         {
221                 void *seed2 = &seed;
222                 int op = my_rand(0,100, seed2);
223                 if (op<60) {
224                         my_els_lookedup++;
225 #ifdef DEBUG
226                         printf("%d[%d]: LOOKUP\n", my_testno, its);
227 #endif                  
228                         if ((my_els_lookedup%1000)==0) {
229                                 printf(".");
230                                 fflush(stdout);
231                         }
232                         if (lookup_element(seed2))
233                                 my_els_found++;
234                 } else if (op < 61) { /* make this 61 and it'll take 16 minutes to run */
235 #ifdef DEBUG
236                         printf("%d[%d]: TRAVERSE\n", my_testno, its);
237 #endif
238                         traverse_elements();
239                         my_els_traversals++;
240                         
241                 } else if (op < 80) {
242 #ifdef DEBUG
243                         printf("%d[%d]: REMOVE\n", my_testno, its);
244 #endif
245                         if (del_element(seed2))
246                                 my_els_removed++;
247                 } else {
248                         my_els_added++;
249 #ifdef DEBUG
250                         printf("%d[%d]: ADD\n", my_testno, its);
251 #endif
252                         add_element();
253                 }
254         }
255         printf("\nhashtest thread %d exiting.... lookups=%d/%d, added=%d, removed=%d, traversals=%d;\n",
256                    my_testno, my_els_found, my_els_lookedup, my_els_added, my_els_removed, my_els_traversals);
257         printf("\ntotals..................... lookups=%d/%d, added=%d, removed=%d; traversals=%d\n",
258                    els_found, els_lookedup, els_added, els_removed, els_traversals);
259         pthread_exit(0);
260         return NULL;
261 }
262
263 static void run_hashtest(int numthr)
264 {
265         pthread_t thr[numthr];
266         void *thrres[numthr];
267         int i;
268         
269         /* init a single global hashtab, then... */
270         glob_hashtab = ao2_container_alloc(180000, hash_string, hashtab_compare_strings);
271
272         /* set a random seed  */
273         glob_seed = (unsigned int)time(0);
274         srand(glob_seed);
275         
276         /* create threads, each running hashtest */
277         for(i=0;i<numthr;i++)
278         {
279                 unsigned long z = rand();
280                 
281                 printf("starting hashtest thread %d....\n",i+1);
282                 if (ast_pthread_create(&thr[i], NULL, hashtest, (void*)z)) {
283                         printf("Sorry, couldn't create thread #%d\n", i+1);
284                 }
285                 printf("hashtest thread spawned.... \n");
286         }
287         /* collect threads, each running hashtest */
288         for(i=0;i<numthr;i++)
289         {
290                 printf("waiting for thread %d....\n", i+1);
291                 if (pthread_join(thr[i], &thrres[i])) {
292                         printf("Sorry, couldn't join thread #%d\n", i+1);
293                 }
294                 printf("hashtest thread %d done.... \n",i+1);
295         }
296         /* user has to kill/intr the process to stop the test? */
297 }
298
299
300 int main(int argc,char **argv)
301 {
302         if (argc < 2 || argc > 2 || atoi(argv[1]) < 1)
303         {
304                 printf("Usage: hashtest <number of threads>\n");
305                 exit(1);
306         }
307         
308         /* one arg == number of threads to create */
309         run_hashtest(atoi(argv[1]));
310         
311         return 0;
312 }
313
314
315 int ast_add_profile(const char *x, uint64_t scale)
316 {
317         return 0;
318 }
319
320 int ast_loader_register(int (*updater)(void))
321 {
322         return 1;
323 }
324
325 int ast_loader_unregister(int (*updater)(void))
326 {
327         return 1;
328 }
329 void ast_module_register(const struct ast_module_info *x)
330 {
331 }
332
333 void ast_module_unregister(const struct ast_module_info *x)
334 {
335 }
336
337
338 void ast_register_file_version(const char *file, const char *version)
339 {
340 }
341
342 void ast_unregister_file_version(const char *file)
343 {
344
345 }
346
347 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
348 {
349         va_list vars;
350         va_start(vars,fmt);
351         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
352                    level, file, line, function);
353         vprintf(fmt, vars);
354         fflush(stdout);
355         va_end(vars);
356 }
357
358 void ast_verbose(const char *fmt, ...)
359 {
360         va_list vars;
361         va_start(vars,fmt);
362
363         printf("VERBOSE: ");
364         vprintf(fmt, vars);
365         fflush(stdout);
366         va_end(vars);
367 }
368
369 void ast_register_thread(char *name)
370 {
371
372 }
373
374 void ast_unregister_thread(void *id)
375 {
376 }