src/vppinfra/bihash_template.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 /** @cond DOCUMENTATION_IS_IN_BIHASH_DOC_H */
  17
  18 void BV (clib_bihash_init)
  19   (BVT (clib_bihash) * h, char *name, u32 nbuckets, uword memory_size)
  20 {
  21   void *oldheap;
  22   int i;
  23
  24   nbuckets = 1 << (max_log2 (nbuckets));
  25
  26   h->name = (u8 *) name;
  27   h->nbuckets = nbuckets;
  28   h->log2_nbuckets = max_log2 (nbuckets);
  29   h->cache_hits = 0;
  30   h->cache_misses = 0;
  31
  32   h->mheap = mheap_alloc (0 /* use VM */ , memory_size);
  33
  34   oldheap = clib_mem_set_heap (h->mheap);
  35   vec_validate_aligned (h->buckets, nbuckets - 1, CLIB_CACHE_LINE_BYTES);
  36   h->writer_lock = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
  37                                            CLIB_CACHE_LINE_BYTES);
  38
  39   for (i = 0; i < nbuckets; i++)
  40     BV (clib_bihash_reset_cache) (h->buckets + i);
  41
  42   clib_mem_set_heap (oldheap);
  43 }
  44
  45 void BV (clib_bihash_free) (BVT (clib_bihash) * h)
  46 {
  47   mheap_free (h->mheap);
  48   memset (h, 0, sizeof (*h));
  49 }
  50
  51 static
  52 BVT (clib_bihash_value) *
  53 BV (value_alloc) (BVT (clib_bihash) * h, u32 log2_pages)
  54 {
  55   BVT (clib_bihash_value) * rv = 0;
  56   void *oldheap;
  57
  58   ASSERT (h->writer_lock[0]);
  59   if (log2_pages >= vec_len (h->freelists) || h->freelists[log2_pages] == 0)
  60     {
  61       oldheap = clib_mem_set_heap (h->mheap);
  62
  63       vec_validate (h->freelists, log2_pages);
  64       rv = clib_mem_alloc_aligned ((sizeof (*rv) * (1 << log2_pages)),
  65                                    CLIB_CACHE_LINE_BYTES);
  66       clib_mem_set_heap (oldheap);
  67       goto initialize;
  68     }
  69   rv = h->freelists[log2_pages];
  70   h->freelists[log2_pages] = rv->next_free;
  71
  72 initialize:
  73   ASSERT (rv);
  74   /*
  75    * Latest gcc complains that the length arg is zero
  76    * if we replace (1<<log2_pages) with vec_len(rv).
  77    * No clue.
  78    */
  79   memset (rv, 0xff, sizeof (*rv) * (1 << log2_pages));
  80   return rv;
  81 }
  82
  83 static void
  84 BV (value_free) (BVT (clib_bihash) * h, BVT (clib_bihash_value) * v,
  85                  u32 log2_pages)
  86 {
  87   ASSERT (h->writer_lock[0]);
  88
  89   ASSERT (vec_len (h->freelists) > log2_pages);
  90
  91   v->next_free = h->freelists[log2_pages];
  92   h->freelists[log2_pages] = v;
  93 }
  94
  95 static inline void
  96 BV (make_working_copy) (BVT (clib_bihash) * h, BVT (clib_bihash_bucket) * b)
  97 {
  98   BVT (clib_bihash_value) * v;
  99   BVT (clib_bihash_bucket) working_bucket __attribute__ ((aligned (8)));
 100   void *oldheap;
 101   BVT (clib_bihash_value) * working_copy;
 102   u32 thread_index = os_get_thread_index ();
 103   int log2_working_copy_length;
 104
 105   if (thread_index >= vec_len (h->working_copies))
 106     {
 107       oldheap = clib_mem_set_heap (h->mheap);
 108       vec_validate (h->working_copies, thread_index);
 109       vec_validate_init_empty (h->working_copy_lengths, thread_index, ~0);
 110       clib_mem_set_heap (oldheap);
 111     }
 112
 113   /*
 114    * working_copies are per-cpu so that near-simultaneous
 115    * updates from multiple threads will not result in sporadic, spurious
 116    * lookup failures.
 117    */
 118   working_copy = h->working_copies[thread_index];
 119   log2_working_copy_length = h->working_copy_lengths[thread_index];
 120
 121   h->saved_bucket.as_u64 = b->as_u64;
 122   oldheap = clib_mem_set_heap (h->mheap);
 123
 124   if (b->log2_pages > log2_working_copy_length)
 125     {
 126       if (working_copy)
 127         clib_mem_free (working_copy);
 128
 129       working_copy = clib_mem_alloc_aligned
 130         (sizeof (working_copy[0]) * (1 << b->log2_pages),
 131          CLIB_CACHE_LINE_BYTES);
 132       h->working_copy_lengths[thread_index] = b->log2_pages;
 133       h->working_copies[thread_index] = working_copy;
 134     }
 135
 136   clib_mem_set_heap (oldheap);
 137
 138   /* Lock the bucket... */
 139   while (BV (clib_bihash_lock_bucket) (b) == 0)
 140     ;
 141
 142   v = BV (clib_bihash_get_value) (h, b->offset);
 143
 144   clib_memcpy (working_copy, v, sizeof (*v) * (1 << b->log2_pages));
 145   working_bucket.as_u64 = b->as_u64;
 146   working_bucket.offset = BV (clib_bihash_get_offset) (h, working_copy);
 147   CLIB_MEMORY_BARRIER ();
 148   b->as_u64 = working_bucket.as_u64;
 149   h->working_copies[thread_index] = working_copy;
 150 }
 151
 152 static
 153 BVT (clib_bihash_value) *
 154 BV (split_and_rehash)
 155   (BVT (clib_bihash) * h,
 156    BVT (clib_bihash_value) * old_values, u32 old_log2_pages,
 157    u32 new_log2_pages)
 158 {
 159   BVT (clib_bihash_value) * new_values, *new_v;
 160   int i, j, length_in_kvs;
 161
 162   new_values = BV (value_alloc) (h, new_log2_pages);
 163   length_in_kvs = (1 << old_log2_pages) * BIHASH_KVP_PER_PAGE;
 164
 165   for (i = 0; i < length_in_kvs; i++)
 166     {
 167       u64 new_hash;
 168
 169       /* Entry not in use? Forget it */
 170       if (BV (clib_bihash_is_free) (&(old_values->kvp[i])))
 171         continue;
 172
 173       /* rehash the item onto its new home-page */
 174       new_hash = BV (clib_bihash_hash) (&(old_values->kvp[i]));
 175       new_hash >>= h->log2_nbuckets;
 176       new_hash &= (1 << new_log2_pages) - 1;
 177       new_v = &new_values[new_hash];
 178
 179       /* Across the new home-page */
 180       for (j = 0; j < BIHASH_KVP_PER_PAGE; j++)
 181         {
 182           /* Empty slot */
 183           if (BV (clib_bihash_is_free) (&(new_v->kvp[j])))
 184             {
 185               clib_memcpy (&(new_v->kvp[j]), &(old_values->kvp[i]),
 186                            sizeof (new_v->kvp[j]));
 187               goto doublebreak;
 188             }
 189         }
 190       /* Crap. Tell caller to try again */
 191       BV (value_free) (h, new_values, new_log2_pages);
 192       return 0;
 193     doublebreak:;
 194     }
 195
 196   return new_values;
 197 }
 198
 199 static
 200 BVT (clib_bihash_value) *
 201 BV (split_and_rehash_linear)
 202   (BVT (clib_bihash) * h,
 203    BVT (clib_bihash_value) * old_values, u32 old_log2_pages,
 204    u32 new_log2_pages)
 205 {
 206   BVT (clib_bihash_value) * new_values;
 207   int i, j, new_length, old_length;
 208
 209   new_values = BV (value_alloc) (h, new_log2_pages);
 210   new_length = (1 << new_log2_pages) * BIHASH_KVP_PER_PAGE;
 211   old_length = (1 << old_log2_pages) * BIHASH_KVP_PER_PAGE;
 212
 213   j = 0;
 214   /* Across the old value array */
 215   for (i = 0; i < old_length; i++)
 216     {
 217       /* Find a free slot in the new linear scan bucket */
 218       for (; j < new_length; j++)
 219         {
 220           /* Old value not in use? Forget it. */
 221           if (BV (clib_bihash_is_free) (&(old_values->kvp[i])))
 222             goto doublebreak;
 223
 224           /* New value should never be in use */
 225           if (BV (clib_bihash_is_free) (&(new_values->kvp[j])))
 226             {
 227               /* Copy the old value and move along */
 228               clib_memcpy (&(new_values->kvp[j]), &(old_values->kvp[i]),
 229                            sizeof (new_values->kvp[j]));
 230               j++;
 231               goto doublebreak;
 232             }
 233         }
 234       /* This should never happen... */
 235       clib_warning ("BUG: linear rehash failed!");
 236       BV (value_free) (h, new_values, new_log2_pages);
 237       return 0;
 238
 239     doublebreak:;
 240     }
 241   return new_values;
 242 }
 243
 244 int BV (clib_bihash_add_del)
 245   (BVT (clib_bihash) * h, BVT (clib_bihash_kv) * add_v, int is_add)
 246 {
 247   u32 bucket_index;
 248   BVT (clib_bihash_bucket) * b, tmp_b;
 249   BVT (clib_bihash_value) * v, *new_v, *save_new_v, *working_copy;
 250   int rv = 0;
 251   int i, limit;
 252   u64 hash, new_hash;
 253   u32 new_log2_pages, old_log2_pages;
 254   u32 thread_index = os_get_thread_index ();
 255   int mark_bucket_linear;
 256   int resplit_once;
 257
 258   hash = BV (clib_bihash_hash) (add_v);
 259
 260   bucket_index = hash & (h->nbuckets - 1);
 261   b = &h->buckets[bucket_index];
 262
 263   hash >>= h->log2_nbuckets;
 264
 265   tmp_b.linear_search = 0;
 266
 267   while (__sync_lock_test_and_set (h->writer_lock, 1))
 268     ;
 269
 270   /* First elt in the bucket? */
 271   if (b->offset == 0)
 272     {
 273       if (is_add == 0)
 274         {
 275           rv = -1;
 276           goto unlock;
 277         }
 278
 279       v = BV (value_alloc) (h, 0);
 280
 281       *v->kvp = *add_v;
 282       tmp_b.as_u64 = 0;
 283       tmp_b.offset = BV (clib_bihash_get_offset) (h, v);
 284
 285       b->as_u64 = tmp_b.as_u64;
 286       goto unlock;
 287     }
 288
 289   /* Note: this leaves the cache disabled */
 290   BV (make_working_copy) (h, b);
 291
 292   v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
 293
 294   limit = BIHASH_KVP_PER_PAGE;
 295   v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
 296   if (b->linear_search)
 297     limit <<= b->log2_pages;
 298
 299   if (is_add)
 300     {
 301       /*
 302        * For obvious (in hindsight) reasons, see if we're supposed to
 303        * replace an existing key, then look for an empty slot.
 304        */
 305       for (i = 0; i < limit; i++)
 306         {
 307           if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
 308             {
 309               clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
 310               CLIB_MEMORY_BARRIER ();
 311               /* Restore the previous (k,v) pairs */
 312               b->as_u64 = h->saved_bucket.as_u64;
 313               goto unlock;
 314             }
 315         }
 316       for (i = 0; i < limit; i++)
 317         {
 318           if (BV (clib_bihash_is_free) (&(v->kvp[i])))
 319             {
 320               clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
 321               CLIB_MEMORY_BARRIER ();
 322               b->as_u64 = h->saved_bucket.as_u64;
 323               goto unlock;
 324             }
 325         }
 326       /* no room at the inn... split case... */
 327     }
 328   else
 329     {
 330       for (i = 0; i < limit; i++)
 331         {
 332           if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
 333             {
 334               memset (&(v->kvp[i]), 0xff, sizeof (*(add_v)));
 335               CLIB_MEMORY_BARRIER ();
 336               b->as_u64 = h->saved_bucket.as_u64;
 337               goto unlock;
 338             }
 339         }
 340       rv = -3;
 341       b->as_u64 = h->saved_bucket.as_u64;
 342       goto unlock;
 343     }
 344
 345   old_log2_pages = h->saved_bucket.log2_pages;
 346   new_log2_pages = old_log2_pages + 1;
 347   mark_bucket_linear = 0;
 348
 349   working_copy = h->working_copies[thread_index];
 350   resplit_once = 0;
 351
 352   new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
 353                                  new_log2_pages);
 354   if (new_v == 0)
 355     {
 356     try_resplit:
 357       resplit_once = 1;
 358       new_log2_pages++;
 359       /* Try re-splitting. If that fails, fall back to linear search */
 360       new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
 361                                      new_log2_pages);
 362       if (new_v == 0)
 363         {
 364         mark_linear:
 365           new_log2_pages--;
 366           /* pinned collisions, use linear search */
 367           new_v =
 368             BV (split_and_rehash_linear) (h, working_copy, old_log2_pages,
 369                                           new_log2_pages);
 370           mark_bucket_linear = 1;
 371         }
 372     }
 373
 374   /* Try to add the new entry */
 375   save_new_v = new_v;
 376   new_hash = BV (clib_bihash_hash) (add_v);
 377   limit = BIHASH_KVP_PER_PAGE;
 378   if (mark_bucket_linear)
 379     limit <<= new_log2_pages;
 380   new_hash >>= h->log2_nbuckets;
 381   new_hash &= (1 << new_log2_pages) - 1;
 382   new_v += mark_bucket_linear ? 0 : new_hash;
 383
 384   for (i = 0; i < limit; i++)
 385     {
 386       if (BV (clib_bihash_is_free) (&(new_v->kvp[i])))
 387         {
 388           clib_memcpy (&(new_v->kvp[i]), add_v, sizeof (*add_v));
 389           goto expand_ok;
 390         }
 391     }
 392
 393   /* Crap. Try again */
 394   BV (value_free) (h, save_new_v, new_log2_pages);
 395   /*
 396    * If we've already doubled the size of the bucket once,
 397    * fall back to linear search now.
 398    */
 399   if (resplit_once)
 400     goto mark_linear;
 401   else
 402     goto try_resplit;
 403
 404 expand_ok:
 405   /* Keep track of the number of linear-scan buckets */
 406   if (tmp_b.linear_search ^ mark_bucket_linear)
 407     h->linear_buckets += (mark_bucket_linear == 1) ? 1 : -1;
 408
 409   tmp_b.log2_pages = new_log2_pages;
 410   tmp_b.offset = BV (clib_bihash_get_offset) (h, save_new_v);
 411   tmp_b.linear_search = mark_bucket_linear;
 412
 413   CLIB_MEMORY_BARRIER ();
 414   b->as_u64 = tmp_b.as_u64;
 415   v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
 416   BV (value_free) (h, v, old_log2_pages);
 417
 418 unlock:
 419   BV (clib_bihash_reset_cache) (b);
 420   BV (clib_bihash_unlock_bucket) (b);
 421   CLIB_MEMORY_BARRIER ();
 422   h->writer_lock[0] = 0;
 423   return rv;
 424 }
 425
 426 int BV (clib_bihash_search)
 427   (BVT (clib_bihash) * h,
 428    BVT (clib_bihash_kv) * search_key, BVT (clib_bihash_kv) * valuep)
 429 {
 430   u64 hash;
 431   u32 bucket_index;
 432   BVT (clib_bihash_value) * v;
 433 #if BIHASH_KVP_CACHE_SIZE > 0
 434   BVT (clib_bihash_kv) * kvp;
 435 #endif
 436   BVT (clib_bihash_bucket) * b;
 437   int i, limit;
 438
 439   ASSERT (valuep);
 440
 441   hash = BV (clib_bihash_hash) (search_key);
 442
 443   bucket_index = hash & (h->nbuckets - 1);
 444   b = &h->buckets[bucket_index];
 445
 446   if (b->offset == 0)
 447     return -1;
 448
 449 #if BIHASH_KVP_CACHE_SIZE > 0
 450   /* Check the cache, if currently enabled */
 451   if (PREDICT_TRUE ((b->cache_lru & (1 << 15)) == 0))
 452     {
 453       limit = BIHASH_KVP_CACHE_SIZE;
 454       kvp = b->cache;
 455       for (i = 0; i < limit; i++)
 456         {
 457           if (BV (clib_bihash_key_compare) (kvp[i].key, search_key->key))
 458             {
 459               *valuep = kvp[i];
 460               h->cache_hits++;
 461               return 0;
 462             }
 463         }
 464     }
 465 #endif
 466
 467   hash >>= h->log2_nbuckets;
 468
 469   v = BV (clib_bihash_get_value) (h, b->offset);
 470   limit = BIHASH_KVP_PER_PAGE;
 471   v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
 472   if (PREDICT_FALSE (b->linear_search))
 473     limit <<= b->log2_pages;
 474
 475   for (i = 0; i < limit; i++)
 476     {
 477       if (BV (clib_bihash_key_compare) (v->kvp[i].key, search_key->key))
 478         {
 479           *valuep = v->kvp[i];
 480
 481 #if BIHASH_KVP_CACHE_SIZE > 0
 482           u8 cache_slot;
 483           /* Shut off the cache */
 484           if (BV (clib_bihash_lock_bucket) (b))
 485             {
 486               cache_slot = BV (clib_bihash_get_lru) (b);
 487               b->cache[cache_slot] = v->kvp[i];
 488               BV (clib_bihash_update_lru) (b, cache_slot);
 489
 490               /* Reenable the cache */
 491               BV (clib_bihash_unlock_bucket) (b);
 492               h->cache_misses++;
 493             }
 494 #endif
 495           return 0;
 496         }
 497     }
 498   return -1;
 499 }
 500
 501 u8 *BV (format_bihash_lru) (u8 * s, va_list * args)
 502 {
 503 #if BIHASH_KVP_SIZE > 0
 504   int i;
 505   BVT (clib_bihash_bucket) * b = va_arg (*args, BVT (clib_bihash_bucket) *);
 506   u16 cache_lru = b->cache_lru;
 507
 508   s = format (s, "cache %s, order ", cache_lru & (1 << 15) ? "on" : "off");
 509
 510   for (i = 0; i < BIHASH_KVP_CACHE_SIZE; i++)
 511     s = format (s, "[%d] ", ((cache_lru >> (3 * i)) & 7));
 512 #else
 513   return format (s, "cache not configured");
 514 #endif
 515   return (s);
 516 }
 517
 518 void
 519 BV (clib_bihash_update_lru_not_inline) (BVT (clib_bihash_bucket) * b, u8 slot)
 520 {
 521 #if BIHASH_KVP_SIZE > 0
 522   BV (clib_bihash_update_lru) (b, slot);
 523 #endif
 524 }
 525
 526 u8 *BV (format_bihash) (u8 * s, va_list * args)
 527 {
 528   BVT (clib_bihash) * h = va_arg (*args, BVT (clib_bihash) *);
 529   int verbose = va_arg (*args, int);
 530   BVT (clib_bihash_bucket) * b;
 531   BVT (clib_bihash_value) * v;
 532   int i, j, k;
 533   u64 active_elements = 0;
 534
 535   s = format (s, "Hash table %s\n", h->name ? h->name : (u8 *) "(unnamed)");
 536
 537   for (i = 0; i < h->nbuckets; i++)
 538     {
 539       b = &h->buckets[i];
 540       if (b->offset == 0)
 541         {
 542           if (verbose > 1)
 543             s = format (s, "[%d]: empty\n", i);
 544           continue;
 545         }
 546
 547       if (verbose)
 548         {
 549           s = format (s, "[%d]: heap offset %d, len %d, linear %d\n", i,
 550                       b->offset, (1 << b->log2_pages), b->linear_search);
 551         }
 552
 553       v = BV (clib_bihash_get_value) (h, b->offset);
 554       for (j = 0; j < (1 << b->log2_pages); j++)
 555         {
 556           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
 557             {
 558               if (BV (clib_bihash_is_free) (&v->kvp[k]))
 559                 {
 560                   if (verbose > 1)
 561                     s = format (s, "    %d: empty\n",
 562                                 j * BIHASH_KVP_PER_PAGE + k);
 563                   continue;
 564                 }
 565               if (verbose)
 566                 {
 567                   s = format (s, "    %d: %U\n",
 568                               j * BIHASH_KVP_PER_PAGE + k,
 569                               BV (format_bihash_kvp), &(v->kvp[k]));
 570                 }
 571               active_elements++;
 572             }
 573           v++;
 574         }
 575     }
 576
 577   s = format (s, "    %lld active elements\n", active_elements);
 578   s = format (s, "    %d free lists\n", vec_len (h->freelists));
 579   s = format (s, "    %d linear search buckets\n", h->linear_buckets);
 580   s = format (s, "    %lld cache hits, %lld cache misses\n",
 581               h->cache_hits, h->cache_misses);
 582   return s;
 583 }
 584
 585 void BV (clib_bihash_foreach_key_value_pair)
 586   (BVT (clib_bihash) * h, void *callback, void *arg)
 587 {
 588   int i, j, k;
 589   BVT (clib_bihash_bucket) * b;
 590   BVT (clib_bihash_value) * v;
 591   void (*fp) (BVT (clib_bihash_kv) *, void *) = callback;
 592
 593   for (i = 0; i < h->nbuckets; i++)
 594     {
 595       b = &h->buckets[i];
 596       if (b->offset == 0)
 597         continue;
 598
 599       v = BV (clib_bihash_get_value) (h, b->offset);
 600       for (j = 0; j < (1 << b->log2_pages); j++)
 601         {
 602           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
 603             {
 604               if (BV (clib_bihash_is_free) (&v->kvp[k]))
 605                 continue;
 606
 607               (*fp) (&v->kvp[k], arg);
 608             }
 609           v++;
 610         }
 611     }
 612 }
 613
 614 /** @endcond */
 615
 616 /*
 617  * fd.io coding-style-patch-verification: ON
 618  *
 619  * Local Variables:
 620  * eval: (c-set-style "gnu")
 621  * End:
 622  */