Re-commit the verbose branch.
[asterisk/asterisk.git] / utils / hashtest.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 /*** MODULEINFO
32         <support_level>extended</support_level>
33  ***/
34
35 #include "asterisk.h"
36 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
37
38 #include <pthread.h>
39 #include <sys/stat.h>
40 #include <signal.h>
41 #include <errno.h>
42 #include "asterisk/lock.h"
43 #include "asterisk/hashtab.h"
44 #include "asterisk/channel.h"
45 #include "asterisk/utils.h"
46 #include "asterisk/module.h"
47 int testno = 1;
48
49 /* stuff we need to make this work with the hashtab stuff */
50 #if !defined(LOW_MEMORY)
51 int64_t ast_mark(int prof_id, int x)
52 {
53         return 0;
54 }
55 #endif
56
57 void pbx_substitute_variables_helper_full(struct ast_channel *c, struct varshead *headp, const char *cp1, char *cp2, int cp2_size, size_t *used);
58 void pbx_substitute_variables_helper_full(struct ast_channel *c, struct varshead *headp, const char *cp1, char *cp2, int cp2_size, size_t *used)
59 {
60 }
61
62 struct ht_element 
63 {
64         char *key;
65         char *val;
66 };
67
68 static int hashtab_compare_strings_nocase(const void *a, const void *b)
69 {
70         const struct ht_element *ae = a, *be = b;
71         return ast_hashtab_compare_strings_nocase(ae->key, be->key);
72 }
73
74 #if 0
75 static int hashtab_compare_strings(const void *a, const void *b)
76 {
77         const struct ht_element *ae = a, *be = b;
78         return ast_hashtab_compare_strings(ae->key, be->key);
79 }
80
81 static unsigned int hashtab_hash_string(const void *obj)
82 {
83         const struct ht_element *o = obj;
84         return ast_hashtab_hash_string((const void *)o->key);
85 }
86 #endif
87
88 static unsigned int hashtab_hash_string_nocase(const void *obj)
89 {
90         const struct ht_element *o = obj;
91         return ast_hashtab_hash_string_nocase((const void*)o->key);
92 }
93
94 /* random numbers */
95
96 static int my_rand(int incl_low, int incl_high, unsigned int *seedp)
97 {
98         if (incl_high == 0)
99                 return 0;
100         
101         return incl_low + (rand_r(seedp) % incl_high);
102 }
103
104
105
106
107 /* the testing routines */
108
109 static int glob_highwater = 0;
110 struct ast_hashtab *glob_hashtab = 0;
111 unsigned int glob_seed = 0;
112 int els_removed = 0;
113 int els_added = 0;
114 int els_lookedup = 0;
115 int els_found = 0;
116 int els_traversals = 0;
117
118 /* all the operations to perform on the hashtab */
119
120 static void add_element(void)
121 {
122         char keybuf[100];
123         struct ht_element *x = malloc(sizeof(struct ht_element));
124         sprintf(keybuf,"key%08d", glob_highwater++);
125         x->key = strdup(keybuf);
126         x->val = strdup("interesting data");
127         ast_hashtab_insert_immediate(glob_hashtab, x);
128         els_added++;
129 }
130
131 static void traverse_elements(void)
132 {
133         struct ht_element *el;
134         int c=0;
135         struct ast_hashtab_iter *it = ast_hashtab_start_write_traversal(glob_hashtab);
136 #ifdef DEBUG
137         printf("Traverse hashtab\n");
138 #endif
139         while ((el = ast_hashtab_next(it))) {
140                 c++;
141         }
142         ast_hashtab_end_traversal(it);
143         els_traversals++; /* unprotected, sometimes off, but, not really important, either */
144 }
145
146 static void * del_element(unsigned int *seedp)
147 {
148         char keybuf[100];
149         struct ht_element *el, lookup;
150         int x;
151         
152         /* pick a random element from 0 to highwater-1 */
153         x = my_rand(0,glob_highwater-1,seedp);
154         sprintf(keybuf, "key%08d", x);
155 #ifdef DEBUG
156         printf("Removing %s", keybuf);
157 #endif
158         lookup.key = keybuf;
159         el = ast_hashtab_remove_object_via_lookup(glob_hashtab, &lookup);
160         
161         if (el) {
162 #ifdef DEBUG
163                 printf("...YES (el=%x)\n", (unsigned long)el);
164 #endif
165                 free(el->key);
166                 free(el->val);
167                 free(el);
168                 els_removed++;
169         } else {
170 #ifdef DEBUG
171                 printf("...NO.\n");
172 #endif
173                 return 0;
174         }
175         
176         
177         return el;
178 }
179
180 static int lookup_element(unsigned int *seedp)
181 {
182         char keybuf[100];
183         struct ht_element *el, lookup;
184         int x;
185         
186         /* pick a random element from 0 to highwater-1 */
187         x = my_rand(0,glob_highwater-1,seedp);
188         sprintf(keybuf, "key%08d", x);
189         lookup.key = keybuf;
190         el = ast_hashtab_lookup(glob_hashtab, &lookup);
191         els_lookedup++;
192         if (el)
193                 els_found++;
194         if (el)
195                 return 1;
196         return 0;
197 }
198
199
200 static void *hashtest(void *data)
201 {
202         int my_els_removed = 0;
203         int my_els_added = 0;
204         int my_els_lookedup = 0;
205         int my_els_found = 0;
206         int my_els_traversals = 0;
207         int my_testno = testno++;
208         int its;
209         
210         /* data will be a random number == use as a seed for random numbers */
211         unsigned long seed = (unsigned long)data;
212
213         printf("hashtest thread created... test beginning\n");
214         
215         /* main test routine-- a global hashtab exists, pound it like crazy  */
216         for(its=0;its<100000;its++)
217         {
218                 void *seed2 = &seed;
219                 int op = my_rand(0,100, seed2);
220                 if (op<60) {
221                         my_els_lookedup++;
222 #ifdef DEBUG
223                         printf("%d[%d]: LOOKUP\n", my_testno, its);
224 #endif                  
225                         if ((my_els_lookedup%1000)==0) {
226                                 printf(".");
227                                 fflush(stdout);
228                         }
229                         if (lookup_element(seed2))
230                                 my_els_found++;
231                 } else if (op < 61) { /* make this 61 and it'll take 15 minutes to run */
232 #ifdef DEBUG
233                         printf("%d[%d]: TRAVERSE\n", my_testno, its);
234 #endif
235                         traverse_elements();
236                         my_els_traversals++;
237                         
238                 } else if (op < 80) {
239 #ifdef DEBUG
240                         printf("%d[%d]: REMOVE\n", my_testno, its);
241 #endif
242                         if (del_element(seed2))
243                                 my_els_removed++;
244                 } else {
245                         my_els_added++;
246 #ifdef DEBUG
247                         printf("%d[%d]: ADD\n", my_testno, its);
248 #endif
249                         add_element();
250                 }
251         }
252         printf("\nhashtest thread %d exiting.... lookups=%d/%d, added=%d, removed=%d, traversals=%d;\n",
253                    my_testno, my_els_found, my_els_lookedup, my_els_added, my_els_removed, my_els_traversals);
254         printf("\ntotals..................... lookups=%d/%d, added=%d, removed=%d, traversals=%d;\n",
255                    els_found, els_lookedup, els_added, els_removed,els_traversals);
256         pthread_exit(0);
257 }
258
259 static void run_hashtest(int numthr)
260 {
261         pthread_t thr[numthr];
262         void *thrres[numthr];
263         int i, biggest, resize_cnt, numobjs, numbuckets;
264         
265         /* init a single global hashtab, then... */
266         glob_hashtab = ast_hashtab_create(180000, hashtab_compare_strings_nocase, ast_hashtab_resize_java, ast_hashtab_newsize_java, hashtab_hash_string_nocase, 1);
267         printf("starting with %d elements in the hashtable...\n", ast_hashtab_capacity(glob_hashtab));
268         /* set a random seed  */
269         glob_seed = (unsigned int)time(0);
270         srand(glob_seed);
271         
272         /* create threads, each running hashtest */
273         for(i=0;i<numthr;i++)
274         {
275                 unsigned long z = rand();
276                 
277                 printf("starting hashtest thread %d....\n",i+1);
278                 if (ast_pthread_create(&thr[i], NULL, hashtest, (void*)z)) {
279                         printf("Sorry, couldn't create thread #%d\n", i+1);
280                 }
281                 printf("hashtest thread spawned.... \n");
282         }
283         /* collect threads, each running hashtest */
284         for(i=0;i<numthr;i++)
285         {
286                 printf("waiting for thread %d....\n", i+1);
287                 if (pthread_join(thr[i], &thrres[i])) {
288                         printf("Sorry, couldn't join thread #%d\n", i+1);
289                 }
290                 printf("hashtest thread %d done.... \n",i+1);
291         }
292         /* user has to kill/intr the process to stop the test? */
293         ast_hashtab_get_stats(glob_hashtab, &biggest, &resize_cnt, &numobjs, &numbuckets);
294         printf("Some stats: longest bucket chain: %d;  number of resizes: %d; number of objects: %d;  capacity: %d\n",
295                         biggest, resize_cnt, numobjs, numbuckets);
296 }
297
298
299 int main(int argc,char **argv)
300 {
301         if (argc < 2 || argc > 2 || atoi(argv[1]) < 1)
302         {
303                 printf("Usage: hashtest <number of threads>\n");
304                 exit(1);
305         }
306         
307         /* one arg == number of threads to create */
308         run_hashtest(atoi(argv[1]));
309         
310         return 0;
311 }
312 #if !defined(LOW_MEMORY)
313 int  ast_add_profile(const char *x, uint64_t scale)
314 {
315         return 0;
316 }
317 #endif
318
319 int ast_loader_register(int (*updater)(void))
320 {
321         return 1;
322 }
323
324 int ast_loader_unregister(int (*updater)(void))
325 {
326         return 1;
327 }
328 void ast_module_register(const struct ast_module_info *x)
329 {
330 }
331
332 void ast_module_unregister(const struct ast_module_info *x)
333 {
334 }
335
336
337 void ast_register_file_version(const char *file, const char *version);
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 void ast_unregister_file_version(const char *file)
344 {
345
346 }
347
348 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
349 {
350         va_list vars;
351         va_start(vars,fmt);
352         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
353                    level, file, line, function);
354         vprintf(fmt, vars);
355         fflush(stdout);
356         va_end(vars);
357 }
358
359 void __ast_verbose(const char *file, int line, const char *func, int level, const char *fmt, ...)
360 {
361         va_list vars;
362         va_start(vars,fmt);
363
364         printf("VERBOSE: ");
365         vprintf(fmt, vars);
366         fflush(stdout);
367         va_end(vars);
368 }
369
370 void ast_register_thread(char *name)
371 {
372
373 }
374
375 void ast_unregister_thread(void *id)
376 {
377 }
378
379 #ifdef HAVE_BKTR
380 struct ast_bt *ast_bt_create(void);
381 struct ast_bt *ast_bt_create(void) 
382 {
383         return NULL;
384 }
385
386 int ast_bt_get_addresses(struct ast_bt *bt);
387 int ast_bt_get_addresses(struct ast_bt *bt)
388 {
389         return 0;
390 }
391
392 char **ast_bt_get_symbols(void **addresses, size_t num_frames);
393 char **ast_bt_get_symbols(void **addresses, size_t num_frames)
394 {
395         char **foo = calloc(num_frames, sizeof(char *) + 1);
396         if (foo) {
397                 int i;
398                 for (i = 0; i < num_frames; i++) {
399                         foo[i] = (char *) foo + sizeof(char *) * num_frames;
400                 }
401         }
402         return foo;
403 }
404
405 void *ast_bt_destroy(struct ast_bt *bt);
406 void *ast_bt_destroy(struct ast_bt *bt)
407 {
408         return NULL;
409 }
410 #endif