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