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