test/lhash_test.c

   1 /*
   2  * Copyright 2017-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2017, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include <openssl/opensslconf.h>
  15 #include <openssl/lhash.h>
  16 #include <openssl/err.h>
  17 #include <openssl/rand.h>
  18 #include <openssl/crypto.h>
  19 #include <internal/hashtable.h>
  20
  21 #include "internal/nelem.h"
  22 #include "threadstest.h"
  23 #include "testutil.h"
  24
  25 /*
  26  * The macros below generate unused functions which error out one of the clang
  27  * builds.  We disable this check here.
  28  */
  29 #ifdef __clang__
  30 #pragma clang diagnostic ignored "-Wunused-function"
  31 #endif
  32
  33 DEFINE_LHASH_OF_EX(int);
  34
  35 static int int_tests[] = { 65537, 13, 1, 3, -5, 6, 7, 4, -10, -12, -14, 22, 9,
  36                            -17, 16, 17, -23, 35, 37, 173, 11 };
  37 static const size_t n_int_tests = OSSL_NELEM(int_tests);
  38 static short int_found[OSSL_NELEM(int_tests)];
  39 static short int_not_found;
  40
  41 static unsigned long int int_hash(const int *p)
  42 {
  43     return 3 & *p;      /* To force collisions */
  44 }
  45
  46 static int int_cmp(const int *p, const int *q)
  47 {
  48     return *p != *q;
  49 }
  50
  51 static int int_find(int n)
  52 {
  53     unsigned int i;
  54
  55     for (i = 0; i < n_int_tests; i++)
  56         if (int_tests[i] == n)
  57             return i;
  58     return -1;
  59 }
  60
  61 static void int_doall(int *v)
  62 {
  63     const int n = int_find(*v);
  64
  65     if (n < 0)
  66         int_not_found++;
  67     else
  68         int_found[n]++;
  69 }
  70
  71 static void int_doall_arg(int *p, short *f)
  72 {
  73     const int n = int_find(*p);
  74
  75     if (n < 0)
  76         int_not_found++;
  77     else
  78         f[n]++;
  79 }
  80
  81 IMPLEMENT_LHASH_DOALL_ARG(int, short);
  82
  83 static int test_int_lhash(void)
  84 {
  85     static struct {
  86         int data;
  87         int null;
  88     } dels[] = {
  89         { 65537,    0 },
  90         { 173,      0 },
  91         { 999,      1 },
  92         { 37,       0 },
  93         { 1,        0 },
  94         { 34,       1 }
  95     };
  96     const unsigned int n_dels = OSSL_NELEM(dels);
  97     LHASH_OF(int) *h = lh_int_new(&int_hash, &int_cmp);
  98     unsigned int i;
  99     int testresult = 0, j, *p;
 100
 101     if (!TEST_ptr(h))
 102         goto end;
 103
 104     /* insert */
 105     for (i = 0; i < n_int_tests; i++)
 106         if (!TEST_ptr_null(lh_int_insert(h, int_tests + i))) {
 107             TEST_info("int insert %d", i);
 108             goto end;
 109         }
 110
 111     /* num_items */
 112     if (!TEST_int_eq((size_t)lh_int_num_items(h), n_int_tests))
 113         goto end;
 114
 115     /* retrieve */
 116     for (i = 0; i < n_int_tests; i++)
 117         if (!TEST_int_eq(*lh_int_retrieve(h, int_tests + i), int_tests[i])) {
 118             TEST_info("lhash int retrieve value %d", i);
 119             goto end;
 120         }
 121     for (i = 0; i < n_int_tests; i++)
 122         if (!TEST_ptr_eq(lh_int_retrieve(h, int_tests + i), int_tests + i)) {
 123             TEST_info("lhash int retrieve address %d", i);
 124             goto end;
 125         }
 126     j = 1;
 127     if (!TEST_ptr_eq(lh_int_retrieve(h, &j), int_tests + 2))
 128         goto end;
 129
 130     /* replace */
 131     j = 13;
 132     if (!TEST_ptr(p = lh_int_insert(h, &j)))
 133         goto end;
 134     if (!TEST_ptr_eq(p, int_tests + 1))
 135         goto end;
 136     if (!TEST_ptr_eq(lh_int_retrieve(h, int_tests + 1), &j))
 137         goto end;
 138
 139     /* do_all */
 140     memset(int_found, 0, sizeof(int_found));
 141     int_not_found = 0;
 142     lh_int_doall(h, &int_doall);
 143     if (!TEST_int_eq(int_not_found, 0)) {
 144         TEST_info("lhash int doall encountered a not found condition");
 145         goto end;
 146     }
 147     for (i = 0; i < n_int_tests; i++)
 148         if (!TEST_int_eq(int_found[i], 1)) {
 149             TEST_info("lhash int doall %d", i);
 150             goto end;
 151         }
 152
 153     /* do_all_arg */
 154     memset(int_found, 0, sizeof(int_found));
 155     int_not_found = 0;
 156     lh_int_doall_short(h, int_doall_arg, int_found);
 157     if (!TEST_int_eq(int_not_found, 0)) {
 158         TEST_info("lhash int doall arg encountered a not found condition");
 159         goto end;
 160     }
 161     for (i = 0; i < n_int_tests; i++)
 162         if (!TEST_int_eq(int_found[i], 1)) {
 163             TEST_info("lhash int doall arg %d", i);
 164             goto end;
 165         }
 166
 167     /* delete */
 168     for (i = 0; i < n_dels; i++) {
 169         const int b = lh_int_delete(h, &dels[i].data) == NULL;
 170         if (!TEST_int_eq(b ^ dels[i].null,  0)) {
 171             TEST_info("lhash int delete %d", i);
 172             goto end;
 173         }
 174     }
 175
 176     /* error */
 177     if (!TEST_int_eq(lh_int_error(h), 0))
 178         goto end;
 179
 180     testresult = 1;
 181 end:
 182     lh_int_free(h);
 183     return testresult;
 184 }
 185
 186
 187 static int int_filter_all(HT_VALUE *v, void *arg)
 188 {
 189     return 1;
 190 }
 191
 192 HT_START_KEY_DEFN(intkey)
 193 HT_DEF_KEY_FIELD(mykey, int)
 194 HT_END_KEY_DEFN(INTKEY)
 195
 196 IMPLEMENT_HT_VALUE_TYPE_FNS(int, test, static)
 197
 198 static int int_foreach(HT_VALUE *v, void *arg)
 199 {
 200     int *vd = ossl_ht_test_int_from_value(v);
 201     const int n = int_find(*vd);
 202
 203     if (n < 0)
 204         int_not_found++;
 205     else
 206         int_found[n]++;
 207     return 1;
 208 }
 209
 210 static uint64_t hashtable_hash(uint8_t *key, size_t keylen)
 211 {
 212     return (uint64_t)(*(uint32_t *)key);
 213 }
 214
 215 static int test_int_hashtable(void)
 216 {
 217     static struct {
 218         int data;
 219         int should_del;
 220     } dels[] = {
 221         { 65537 , 1},
 222         { 173 , 1},
 223         { 999 , 0 },
 224         { 37 , 1 },
 225         { 1 , 1 },
 226         { 34 , 0 }
 227     };
 228     const size_t n_dels = OSSL_NELEM(dels);
 229     HT_CONFIG hash_conf = {
 230         NULL,
 231         NULL,
 232         NULL,
 233         0,
 234     };
 235     INTKEY key;
 236     int rc = 0;
 237     size_t i;
 238     HT *ht = NULL;
 239     int todel;
 240     HT_VALUE_LIST *list = NULL;
 241
 242     ht = ossl_ht_new(&hash_conf);
 243
 244     if (ht == NULL)
 245         return 0;
 246
 247     /* insert */
 248     HT_INIT_KEY(&key);
 249     for (i = 0; i < n_int_tests; i++) {
 250         HT_SET_KEY_FIELD(&key, mykey, int_tests[i]);
 251         if (!TEST_int_eq(ossl_ht_test_int_insert(ht, TO_HT_KEY(&key),
 252                          &int_tests[i], NULL), 1)) {
 253             TEST_info("int insert %zu", i);
 254             goto end;
 255         }
 256     }
 257
 258     /* num_items */
 259     if (!TEST_int_eq((size_t)ossl_ht_count(ht), n_int_tests))
 260         goto end;
 261
 262     /* foreach, no arg */
 263     memset(int_found, 0, sizeof(int_found));
 264     int_not_found = 0;
 265     ossl_ht_foreach_until(ht, int_foreach, NULL);
 266     if (!TEST_int_eq(int_not_found, 0)) {
 267         TEST_info("hashtable int foreach encountered a not found condition");
 268         goto end;
 269     }
 270
 271     for (i = 0; i < n_int_tests; i++)
 272         if (!TEST_int_eq(int_found[i], 1)) {
 273             TEST_info("hashtable int foreach %zu", i);
 274             goto end;
 275     }
 276
 277     /* filter */
 278     list = ossl_ht_filter(ht, 64, int_filter_all, NULL);
 279     if (!TEST_int_eq((size_t)list->list_len, n_int_tests))
 280         goto end;
 281     ossl_ht_value_list_free(list);
 282
 283     /* delete */
 284     for (i = 0; i < n_dels; i++) {
 285         HT_SET_KEY_FIELD(&key, mykey, dels[i].data);
 286         todel = ossl_ht_delete(ht, TO_HT_KEY(&key));
 287         if (dels[i].should_del) {
 288             if (!TEST_int_eq(todel, 1)) {
 289                 TEST_info("hashtable couldn't find entry %d to delete\n",
 290                           dels[i].data);
 291                 goto end;
 292             }
 293         } else {
 294             if (!TEST_int_eq(todel, 0)) {
 295                 TEST_info("%d found an entry that shouldn't be there\n", dels[i].data);
 296                 goto end;
 297             }
 298        }
 299     }
 300
 301     rc = 1;
 302 end:
 303     ossl_ht_free(ht);
 304     return rc;
 305 }
 306
 307 static unsigned long int stress_hash(const int *p)
 308 {
 309     return *p;
 310 }
 311
 312 #ifdef MEASURE_HASH_PERFORMANCE
 313 static int
 314 timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y)
 315 {
 316     /* Perform the carry for the later subtraction by updating y. */
 317     if (x->tv_usec < y->tv_usec) {
 318         int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
 319         y->tv_usec -= 1000000 * nsec;
 320         y->tv_sec += nsec;
 321     }
 322     if (x->tv_usec - y->tv_usec > 1000000) {
 323         int nsec = (x->tv_usec - y->tv_usec) / 1000000;
 324         y->tv_usec += 1000000 * nsec;
 325         y->tv_sec -= nsec;
 326     }
 327
 328     /*
 329      * Compute the time remaining to wait.
 330      * tv_usec is certainly positive.
 331      */
 332     result->tv_sec = x->tv_sec - y->tv_sec;
 333     result->tv_usec = x->tv_usec - y->tv_usec;
 334
 335     /* Return 1 if result is negative. */
 336     return x->tv_sec < y->tv_sec;
 337 }
 338 #endif
 339
 340 static int test_stress(void)
 341 {
 342     LHASH_OF(int) *h = lh_int_new(&stress_hash, &int_cmp);
 343     const unsigned int n = 2500000;
 344     unsigned int i;
 345     int testresult = 0, *p;
 346 #ifdef MEASURE_HASH_PERFORMANCE
 347     struct timeval start, end, delta;
 348 #endif
 349
 350     if (!TEST_ptr(h))
 351         goto end;
 352 #ifdef MEASURE_HASH_PERFORMANCE
 353     gettimeofday(&start, NULL);
 354 #endif
 355     /* insert */
 356     for (i = 0; i < n; i++) {
 357         p = OPENSSL_malloc(sizeof(i));
 358         if (!TEST_ptr(p)) {
 359             TEST_info("lhash stress out of memory %d", i);
 360             goto end;
 361         }
 362         *p = 3 * i + 1;
 363         lh_int_insert(h, p);
 364     }
 365
 366     /* num_items */
 367     if (!TEST_int_eq(lh_int_num_items(h), n))
 368             goto end;
 369
 370     /* delete in a different order */
 371     for (i = 0; i < n; i++) {
 372         const int j = (7 * i + 4) % n * 3 + 1;
 373
 374         if (!TEST_ptr(p = lh_int_delete(h, &j))) {
 375             TEST_info("lhash stress delete %d\n", i);
 376             goto end;
 377         }
 378         if (!TEST_int_eq(*p, j)) {
 379             TEST_info("lhash stress bad value %d", i);
 380             goto end;
 381         }
 382         OPENSSL_free(p);
 383     }
 384
 385     testresult = 1;
 386 end:
 387 #ifdef MEASURE_HASH_PERFORMANCE
 388     gettimeofday(&end, NULL);
 389     timeval_subtract(&delta, &end, &start);
 390     TEST_info("lhash stress runs in %ld.%ld seconds", delta.tv_sec, delta.tv_usec);
 391 #endif
 392     lh_int_free(h);
 393     return testresult;
 394 }
 395
 396 static void hashtable_intfree(HT_VALUE *v)
 397 {
 398     OPENSSL_free(v->value);
 399 }
 400
 401 static int test_hashtable_stress(void)
 402 {
 403     const unsigned int n = 2500000;
 404     unsigned int i;
 405     int testresult = 0, *p;
 406     HT_CONFIG hash_conf = {
 407         NULL,              /* use default context */
 408         hashtable_intfree, /* our free function */
 409         hashtable_hash,    /* our hash function */
 410         625000,            /* preset hash size */
 411     };
 412     HT *h;
 413     INTKEY key;
 414 #ifdef MEASURE_HASH_PERFORMANCE
 415     struct timeval start, end, delta;
 416 #endif
 417
 418     h = ossl_ht_new(&hash_conf);
 419
 420
 421     if (!TEST_ptr(h))
 422         goto end;
 423 #ifdef MEASURE_HASH_PERFORMANCE
 424     gettimeofday(&start, NULL);
 425 #endif
 426
 427     HT_INIT_KEY(&key);
 428
 429     /* insert */
 430     for (i = 0; i < n; i++) {
 431         p = OPENSSL_malloc(sizeof(i));
 432         if (!TEST_ptr(p)) {
 433             TEST_info("hashtable stress out of memory %d", i);
 434             goto end;
 435         }
 436         *p = 3 * i + 1;
 437         HT_SET_KEY_FIELD(&key, mykey, *p);
 438         if (!TEST_int_eq(ossl_ht_test_int_insert(h, TO_HT_KEY(&key),
 439                          p, NULL), 1)) {
 440             TEST_info("hashtable unable to insert element %d\n", *p);
 441             goto end;
 442         }
 443     }
 444
 445     /* make sure we stored everything */
 446     if (!TEST_int_eq((size_t)ossl_ht_count(h), n))
 447             goto end;
 448
 449     /* delete in a different order */
 450     for (i = 0; i < n; i++) {
 451         const int j = (7 * i + 4) % n * 3 + 1;
 452         HT_SET_KEY_FIELD(&key, mykey, j);
 453         if (!TEST_int_eq((ossl_ht_delete(h, TO_HT_KEY(&key))), 1)) {
 454             TEST_info("hashtable didn't delete key %d\n", j);
 455             goto end;
 456         }
 457     }
 458
 459     testresult = 1;
 460 end:
 461 #ifdef MEASURE_HASH_PERFORMANCE
 462     gettimeofday(&end, NULL);
 463     timeval_subtract(&delta, &end, &start);
 464     TEST_info("hashtable stress runs in %ld.%ld seconds", delta.tv_sec, delta.tv_usec);
 465 #endif
 466     ossl_ht_free(h);
 467     return testresult;
 468 }
 469
 470 typedef struct test_mt_entry {
 471     int in_table;
 472     int pending_delete;
 473 } TEST_MT_ENTRY;
 474
 475 static HT *m_ht = NULL;
 476 #define TEST_MT_POOL_SZ 256
 477 #define TEST_THREAD_ITERATIONS 10000
 478
 479 static struct test_mt_entry test_mt_entries[TEST_MT_POOL_SZ];
 480 static char *worker_exits[4];
 481
 482 HT_START_KEY_DEFN(mtkey)
 483 HT_DEF_KEY_FIELD(index, unsigned int)
 484 HT_END_KEY_DEFN(MTKEY)
 485
 486 IMPLEMENT_HT_VALUE_TYPE_FNS(TEST_MT_ENTRY, mt, static)
 487
 488 static int worker_num = 0;
 489 static CRYPTO_RWLOCK *worker_lock;
 490 static int free_failure = 0;
 491 static int shutting_down = 0;
 492 static int global_iteration = 0;
 493
 494 static void hashtable_mt_free(HT_VALUE *v)
 495 {
 496     TEST_MT_ENTRY *m = ossl_ht_mt_TEST_MT_ENTRY_from_value(v);
 497     int pending_delete;
 498     int ret;
 499
 500     CRYPTO_atomic_load_int(&m->pending_delete, &pending_delete, worker_lock);
 501
 502     if (shutting_down == 1)
 503         return;
 504
 505     if (pending_delete == 0) {
 506         TEST_info("Freeing element which was not scheduled for free");
 507         free_failure = 1;
 508     } else {
 509         CRYPTO_atomic_add(&m->pending_delete, -1,
 510                           &ret, worker_lock);
 511     }
 512 }
 513
 514 #define BEHAVIOR_MASK 0x3
 515 #define DO_LOOKUP 0
 516 #define DO_INSERT 1
 517 #define DO_REPLACE 2
 518 #define DO_DELETE 3
 519
 520 static void do_mt_hash_work(void)
 521 {
 522     MTKEY key;
 523     unsigned int index;
 524     int num;
 525     TEST_MT_ENTRY *m;
 526     TEST_MT_ENTRY *expected_m = NULL;
 527     HT_VALUE *v = NULL;
 528     TEST_MT_ENTRY **r = NULL;
 529     int expected_rc;
 530     int ret;
 531     char behavior;
 532     size_t iter = 0;
 533     int giter;
 534
 535     CRYPTO_atomic_add(&worker_num, 1, &num, worker_lock);
 536     num--; /* atomic_add is an add/fetch operation */
 537
 538     HT_INIT_KEY(&key);
 539
 540     for (iter = 0; iter < TEST_THREAD_ITERATIONS; iter++) {
 541         if (!RAND_bytes((unsigned char *)&index, sizeof(unsigned int))) {
 542             worker_exits[num] = "Failed to get random index";
 543             return;
 544         }
 545         index %= TEST_MT_POOL_SZ;
 546         if (!RAND_bytes((unsigned char *)&behavior, sizeof(char))) {
 547             worker_exits[num] = "Failed to get random behavior";
 548             return;
 549         }
 550         behavior &= BEHAVIOR_MASK;
 551
 552         expected_m = &test_mt_entries[index];
 553         HT_KEY_RESET(&key);
 554         HT_SET_KEY_FIELD(&key, index, index);
 555
 556         if (!CRYPTO_atomic_add(&global_iteration, 1, &giter, worker_lock)) {
 557             worker_exits[num] = "Unable to increment global iterator";
 558             return;
 559         }
 560         switch(behavior) {
 561         case DO_LOOKUP:
 562             ossl_ht_read_lock(m_ht);
 563             m = ossl_ht_mt_TEST_MT_ENTRY_get(m_ht, TO_HT_KEY(&key), &v);
 564             if (m != NULL && m != expected_m) {
 565                 worker_exits[num] = "Read unexpected value from hashtable";
 566                 TEST_info("Iteration %d Read unexpected value %p when %p expected",
 567                           giter, (void *)m, (void *)expected_m);
 568             }
 569             ossl_ht_read_unlock(m_ht);
 570             if (worker_exits[num] != NULL)
 571                 return;
 572             break;
 573         case DO_INSERT:
 574         case DO_REPLACE:
 575             ossl_ht_write_lock(m_ht);
 576             if (behavior == DO_REPLACE) {
 577                 expected_rc = 1;
 578                 r = &m;
 579             } else {
 580                 expected_rc = !expected_m->in_table;
 581                 r = NULL;
 582             }
 583
 584             if (expected_rc != ossl_ht_mt_TEST_MT_ENTRY_insert(m_ht,
 585                                                                TO_HT_KEY(&key),
 586                                                                expected_m, r)) {
 587                 TEST_info("Iteration %d Expected rc %d on %s of element %d which is %s\n",
 588                           giter, expected_rc, behavior == DO_REPLACE ? "replace" : "insert",
 589                           index, expected_m->in_table ? "in table" : "not in table");
 590                 worker_exits[num] = "Failure on insert";
 591             }
 592             if (expected_rc == 1)
 593                 expected_m->in_table = 1;
 594             ossl_ht_write_unlock(m_ht);
 595             if (worker_exits[num] != NULL)
 596                 return;
 597             break;
 598         case DO_DELETE:
 599             ossl_ht_write_lock(m_ht);
 600             expected_rc = expected_m->in_table;
 601             if (expected_rc != ossl_ht_delete(m_ht, TO_HT_KEY(&key))) {
 602                 TEST_info("Iteration %d Expected rc %d on delete of element %d which is %s\n",
 603                           giter, expected_rc, index,
 604                           expected_m->in_table ? "in table" : "not in table");
 605                 worker_exits[num] = "Failure on delete";
 606             }
 607             if (expected_rc == 1) {
 608                 expected_m->in_table = 0;
 609                 CRYPTO_atomic_add(&expected_m->pending_delete, 1, &ret, worker_lock);
 610             }
 611             ossl_ht_write_unlock(m_ht);
 612             if (worker_exits[num] != NULL)
 613                 return;
 614             break;
 615         default:
 616             worker_exits[num] = "Undefined behavior specified";
 617             return;
 618         }
 619     }
 620 }
 621
 622 static int test_hashtable_multithread(void)
 623 {
 624     HT_CONFIG hash_conf = {
 625         NULL,              /* use default context */
 626         hashtable_mt_free, /* our free function */
 627         NULL,              /* default hash function */
 628         0,                 /* default hash size */
 629     };
 630     int ret = 0;
 631     thread_t workers[4];
 632     int i;
 633 #ifdef MEASURE_HASH_PERFORMANCE
 634     struct timeval start, end, delta;
 635 #endif
 636
 637     memset(worker_exits, 0, sizeof(char *) * 4);
 638     memset(test_mt_entries, 0, sizeof(TEST_MT_ENTRY) * TEST_MT_POOL_SZ);
 639     memset(workers, 0, sizeof(thread_t) * 4);
 640
 641     m_ht = ossl_ht_new(&hash_conf);
 642
 643     if (!TEST_ptr(m_ht))
 644         goto end;
 645
 646     worker_lock = CRYPTO_THREAD_lock_new();
 647     if (worker_lock == NULL)
 648         goto end_free;
 649 #ifdef MEASURE_HASH_PERFORMANCE
 650     gettimeofday(&start, NULL);
 651 #endif
 652
 653     for (i = 0; i < 4; i++) {
 654         if (!run_thread(&workers[i], do_mt_hash_work))
 655             goto shutdown;
 656     }
 657
 658 shutdown:
 659     for (--i; i >= 0; i--) {
 660         wait_for_thread(workers[i]);
 661     }
 662
 663
 664     /*
 665      * Now that the workers are done, check for any error
 666      * conditions
 667      */
 668     ret = 1;
 669     for (i = 0; i < 4; i++) {
 670         if (worker_exits[i] != NULL) {
 671             TEST_info("Worker %d failed: %s\n", i, worker_exits[i]);
 672             ret = 0;
 673         }
 674     }
 675     if (free_failure == 1) {
 676         TEST_info("Encountered a free failure");
 677         ret = 0;
 678     }
 679
 680 #ifdef MEASURE_HASH_PERFORMANCE
 681     gettimeofday(&end, NULL);
 682     timeval_subtract(&delta, &end, &start);
 683     TEST_info("multithread stress runs 40000 ops in %ld.%ld seconds", delta.tv_sec, delta.tv_usec);
 684 #endif
 685
 686 end_free:
 687     shutting_down = 1;
 688     ossl_ht_free(m_ht);
 689 end:
 690     return ret;
 691 }
 692
 693 int setup_tests(void)
 694 {
 695     ADD_TEST(test_int_lhash);
 696     ADD_TEST(test_stress);
 697     ADD_TEST(test_int_hashtable);
 698     ADD_TEST(test_hashtable_stress);
 699     ADD_TEST(test_hashtable_multithread);
 700     return 1;
 701 }