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