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 }