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