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