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