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   /* Turn off the cache */
 139   BV (clib_bihash_cache_enable_disable) (b, 0);
 140
 141   v = BV (clib_bihash_get_value) (h, b->offset);
 142
 143   clib_memcpy (working_copy, v, sizeof (*v) * (1 << b->log2_pages));
 144   working_bucket.as_u64 = b->as_u64;
 145   working_bucket.offset = BV (clib_bihash_get_offset) (h, working_copy);
 146   CLIB_MEMORY_BARRIER ();
 147   b->as_u64 = working_bucket.as_u64;
 148   h->working_copies[thread_index] = working_copy;
 149 }
 150
 151 static
 152 BVT (clib_bihash_value) *
 153 BV (split_and_rehash)
 154   (BVT (clib_bihash) * h,
 155    BVT (clib_bihash_value) * old_values, u32 old_log2_pages,
 156    u32 new_log2_pages)
 157 {
 158   BVT (clib_bihash_value) * new_values, *new_v;
 159   int i, j, length_in_kvs;
 160
 161   new_values = BV (value_alloc) (h, new_log2_pages);
 162   length_in_kvs = (1 << old_log2_pages) * BIHASH_KVP_PER_PAGE;
 163
 164   for (i = 0; i < length_in_kvs; i++)
 165     {
 166       u64 new_hash;
 167
 168       /* Entry not in use? Forget it */
 169       if (BV (clib_bihash_is_free) (&(old_values->kvp[i])))
 170         continue;
 171
 172       /* rehash the item onto its new home-page */
 173       new_hash = BV (clib_bihash_hash) (&(old_values->kvp[i]));
 174       new_hash >>= h->log2_nbuckets;
 175       new_hash &= (1 << new_log2_pages) - 1;
 176       new_v = &new_values[new_hash];
 177
 178       /* Across the new home-page */
 179       for (j = 0; j < BIHASH_KVP_PER_PAGE; j++)
 180         {
 181           /* Empty slot */
 182           if (BV (clib_bihash_is_free) (&(new_v->kvp[j])))
 183             {
 184               clib_memcpy (&(new_v->kvp[j]), &(old_values->kvp[i]),
 185                            sizeof (new_v->kvp[j]));
 186               goto doublebreak;
 187             }
 188         }
 189       /* Crap. Tell caller to try again */
 190       BV (value_free) (h, new_values, new_log2_pages);
 191       return 0;
 192     doublebreak:;
 193     }
 194
 195   return new_values;
 196 }
 197
 198 static
 199 BVT (clib_bihash_value) *
 200 BV (split_and_rehash_linear)
 201   (BVT (clib_bihash) * h,
 202    BVT (clib_bihash_value) * old_values, u32 old_log2_pages,
 203    u32 new_log2_pages)
 204 {
 205   BVT (clib_bihash_value) * new_values;
 206   int i, j, new_length, old_length;
 207
 208   new_values = BV (value_alloc) (h, new_log2_pages);
 209   new_length = (1 << new_log2_pages) * BIHASH_KVP_PER_PAGE;
 210   old_length = (1 << old_log2_pages) * BIHASH_KVP_PER_PAGE;
 211
 212   j = 0;
 213   /* Across the old value array */
 214   for (i = 0; i < old_length; i++)
 215     {
 216       /* Find a free slot in the new linear scan bucket */
 217       for (; j < new_length; j++)
 218         {
 219           /* Old value not in use? Forget it. */
 220           if (BV (clib_bihash_is_free) (&(old_values->kvp[i])))
 221             goto doublebreak;
 222
 223           /* New value should never be in use */
 224           if (BV (clib_bihash_is_free) (&(new_values->kvp[j])))
 225             {
 226               /* Copy the old value and move along */
 227               clib_memcpy (&(new_values->kvp[j]), &(old_values->kvp[i]),
 228                            sizeof (new_values->kvp[j]));
 229               j++;
 230               goto doublebreak;
 231             }
 232         }
 233       /* This should never happen... */
 234       clib_warning ("BUG: linear rehash failed!");
 235       BV (value_free) (h, new_values, new_log2_pages);
 236       return 0;
 237
 238     doublebreak:;
 239     }
 240   return new_values;
 241 }
 242
 243 int BV (clib_bihash_add_del)
 244   (BVT (clib_bihash) * h, BVT (clib_bihash_kv) * add_v, int is_add)
 245 {
 246   u32 bucket_index;
 247   BVT (clib_bihash_bucket) * b, tmp_b;
 248   BVT (clib_bihash_value) * v, *new_v, *save_new_v, *working_copy;
 249   int rv = 0;
 250   int i, limit;
 251   u64 hash, new_hash;
 252   u32 new_log2_pages, old_log2_pages;
 253   u32 thread_index = os_get_thread_index ();
 254   int mark_bucket_linear;
 255   int resplit_once;
 256
 257   hash = BV (clib_bihash_hash) (add_v);
 258
 259   bucket_index = hash & (h->nbuckets - 1);
 260   b = &h->buckets[bucket_index];
 261
 262   hash >>= h->log2_nbuckets;
 263
 264   tmp_b.linear_search = 0;
 265
 266   while (__sync_lock_test_and_set (h->writer_lock, 1))
 267     ;
 268
 269   /* First elt in the bucket? */
 270   if (b->offset == 0)
 271     {
 272       if (is_add == 0)
 273         {
 274           rv = -1;
 275           goto unlock;
 276         }
 277
 278       v = BV (value_alloc) (h, 0);
 279
 280       *v->kvp = *add_v;
 281       tmp_b.as_u64 = 0;
 282       tmp_b.offset = BV (clib_bihash_get_offset) (h, v);
 283
 284       b->as_u64 = tmp_b.as_u64;
 285       goto unlock;
 286     }
 287
 288   /* Note: this leaves the cache disabled */
 289   BV (make_working_copy) (h, b);
 290
 291   v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
 292
 293   limit = BIHASH_KVP_PER_PAGE;
 294   v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
 295   if (b->linear_search)
 296     limit <<= b->log2_pages;
 297
 298   if (is_add)
 299     {
 300       /*
 301        * For obvious (in hindsight) reasons, see if we're supposed to
 302        * replace an existing key, then look for an empty slot.
 303        */
 304       for (i = 0; i < limit; i++)
 305         {
 306           if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
 307             {
 308               clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
 309               CLIB_MEMORY_BARRIER ();
 310               /* Restore the previous (k,v) pairs */
 311               b->as_u64 = h->saved_bucket.as_u64;
 312               goto unlock;
 313             }
 314         }
 315       for (i = 0; i < limit; i++)
 316         {
 317           if (BV (clib_bihash_is_free) (&(v->kvp[i])))
 318             {
 319               clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
 320               CLIB_MEMORY_BARRIER ();
 321               b->as_u64 = h->saved_bucket.as_u64;
 322               goto unlock;
 323             }
 324         }
 325       /* no room at the inn... split case... */
 326     }
 327   else
 328     {
 329       for (i = 0; i < limit; i++)
 330         {
 331           if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
 332             {
 333               memset (&(v->kvp[i]), 0xff, sizeof (*(add_v)));
 334               CLIB_MEMORY_BARRIER ();
 335               b->as_u64 = h->saved_bucket.as_u64;
 336               goto unlock;
 337             }
 338         }
 339       rv = -3;
 340       b->as_u64 = h->saved_bucket.as_u64;
 341       goto unlock;
 342     }
 343
 344   old_log2_pages = h->saved_bucket.log2_pages;
 345   new_log2_pages = old_log2_pages + 1;
 346   mark_bucket_linear = 0;
 347
 348   working_copy = h->working_copies[thread_index];
 349   resplit_once = 0;
 350
 351   new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
 352                                  new_log2_pages);
 353   if (new_v == 0)
 354     {
 355     try_resplit:
 356       resplit_once = 1;
 357       new_log2_pages++;
 358       /* Try re-splitting. If that fails, fall back to linear search */
 359       new_v = BV (split_and_rehash) (h, working_copy, old_log2_pages,
 360                                      new_log2_pages);
 361       if (new_v == 0)
 362         {
 363         mark_linear:
 364           new_log2_pages--;
 365           /* pinned collisions, use linear search */
 366           new_v =
 367             BV (split_and_rehash_linear) (h, working_copy, old_log2_pages,
 368                                           new_log2_pages);
 369           mark_bucket_linear = 1;
 370         }
 371     }
 372
 373   /* Try to add the new entry */
 374   save_new_v = new_v;
 375   new_hash = BV (clib_bihash_hash) (add_v);
 376   limit = BIHASH_KVP_PER_PAGE;
 377   if (mark_bucket_linear)
 378     limit <<= new_log2_pages;
 379   new_hash >>= h->log2_nbuckets;
 380   new_hash &= (1 << new_log2_pages) - 1;
 381   new_v += mark_bucket_linear ? 0 : new_hash;
 382
 383   for (i = 0; i < limit; i++)
 384     {
 385       if (BV (clib_bihash_is_free) (&(new_v->kvp[i])))
 386         {
 387           clib_memcpy (&(new_v->kvp[i]), add_v, sizeof (*add_v));
 388           goto expand_ok;
 389         }
 390     }
 391
 392   /* Crap. Try again */
 393   BV (value_free) (h, save_new_v, new_log2_pages);
 394   /*
 395    * If we've already doubled the size of the bucket once,
 396    * fall back to linear search now.
 397    */
 398   if (resplit_once)
 399     goto mark_linear;
 400   else
 401     goto try_resplit;
 402
 403 expand_ok:
 404   /* Keep track of the number of linear-scan buckets */
 405   if (tmp_b.linear_search ^ mark_bucket_linear)
 406     h->linear_buckets += (mark_bucket_linear == 1) ? 1 : -1;
 407
 408   tmp_b.log2_pages = new_log2_pages;
 409   tmp_b.offset = BV (clib_bihash_get_offset) (h, save_new_v);
 410   tmp_b.linear_search = mark_bucket_linear;
 411
 412   CLIB_MEMORY_BARRIER ();
 413   b->as_u64 = tmp_b.as_u64;
 414   v = BV (clib_bihash_get_value) (h, h->saved_bucket.offset);
 415   BV (value_free) (h, v, old_log2_pages);
 416
 417 unlock:
 418   BV (clib_bihash_reset_cache) (b);
 419   BV (clib_bihash_cache_enable_disable) (b, 1 /* enable */ );
 420   CLIB_MEMORY_BARRIER ();
 421   h->writer_lock[0] = 0;
 422   return rv;
 423 }
 424
 425 int BV (clib_bihash_search)
 426   (BVT (clib_bihash) * h,
 427    BVT (clib_bihash_kv) * search_key, BVT (clib_bihash_kv) * valuep)
 428 {
 429   u64 hash;
 430   u32 bucket_index;
 431   BVT (clib_bihash_value) * v;
 432   BVT (clib_bihash_kv) * kvp;
 433   BVT (clib_bihash_bucket) * b;
 434   int i, limit;
 435
 436   ASSERT (valuep);
 437
 438   hash = BV (clib_bihash_hash) (search_key);
 439
 440   bucket_index = hash & (h->nbuckets - 1);
 441   b = &h->buckets[bucket_index];
 442
 443   if (b->offset == 0)
 444     return -1;
 445
 446   /* Check the cache, if currently enabled */
 447   if (PREDICT_TRUE (b->cache_lru & (1 << 15)))
 448     {
 449       limit = BIHASH_KVP_CACHE_SIZE;
 450       kvp = b->cache;
 451       for (i = 0; i < limit; i++)
 452         {
 453           if (BV (clib_bihash_key_compare) (kvp[i].key, search_key->key))
 454             {
 455               *valuep = kvp[i];
 456               h->cache_hits++;
 457               return 0;
 458             }
 459         }
 460     }
 461
 462   hash >>= h->log2_nbuckets;
 463
 464   v = BV (clib_bihash_get_value) (h, b->offset);
 465   limit = BIHASH_KVP_PER_PAGE;
 466   v += (b->linear_search == 0) ? hash & ((1 << b->log2_pages) - 1) : 0;
 467   if (PREDICT_FALSE (b->linear_search))
 468     limit <<= b->log2_pages;
 469
 470   for (i = 0; i < limit; i++)
 471     {
 472       if (BV (clib_bihash_key_compare) (v->kvp[i].key, search_key->key))
 473         {
 474           u8 cache_slot;
 475           *valuep = v->kvp[i];
 476
 477           /* Shut off the cache */
 478           BV (clib_bihash_cache_enable_disable) (b, 0);
 479           CLIB_MEMORY_BARRIER ();
 480
 481           cache_slot = BV (clib_bihash_get_lru) (b);
 482           b->cache[cache_slot] = v->kvp[i];
 483           BV (clib_bihash_update_lru) (b, cache_slot);
 484
 485           /* Reenable the cache */
 486           BV (clib_bihash_cache_enable_disable) (b, 1);
 487           h->cache_misses++;
 488           return 0;
 489         }
 490     }
 491   return -1;
 492 }
 493
 494 u8 *BV (format_bihash_lru) (u8 * s, va_list * args)
 495 {
 496   int i;
 497   BVT (clib_bihash_bucket) * b = va_arg (*args, BVT (clib_bihash_bucket) *);
 498   u16 cache_lru = b->cache_lru;
 499
 500   s = format (s, "cache %s, order ", cache_lru & (1 << 15) ? "on" : "off");
 501
 502   for (i = 0; i < BIHASH_KVP_CACHE_SIZE; i++)
 503     s = format (s, "[%d] ", ((cache_lru >> (3 * i)) & 7));
 504   return (s);
 505 }
 506
 507 void
 508 BV (clib_bihash_update_lru_not_inline) (BVT (clib_bihash_bucket) * b, u8 slot)
 509 {
 510   BV (clib_bihash_update_lru) (b, slot);
 511 }
 512
 513 u8 *BV (format_bihash) (u8 * s, va_list * args)
 514 {
 515   BVT (clib_bihash) * h = va_arg (*args, BVT (clib_bihash) *);
 516   int verbose = va_arg (*args, int);
 517   BVT (clib_bihash_bucket) * b;
 518   BVT (clib_bihash_value) * v;
 519   int i, j, k;
 520   u64 active_elements = 0;
 521
 522   s = format (s, "Hash table %s\n", h->name ? h->name : (u8 *) "(unnamed)");
 523
 524   for (i = 0; i < h->nbuckets; i++)
 525     {
 526       b = &h->buckets[i];
 527       if (b->offset == 0)
 528         {
 529           if (verbose > 1)
 530             s = format (s, "[%d]: empty\n", i);
 531           continue;
 532         }
 533
 534       if (verbose)
 535         {
 536           s = format (s, "[%d]: heap offset %d, len %d, linear %d\n", i,
 537                       b->offset, (1 << b->log2_pages), b->linear_search);
 538         }
 539
 540       v = BV (clib_bihash_get_value) (h, b->offset);
 541       for (j = 0; j < (1 << b->log2_pages); j++)
 542         {
 543           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
 544             {
 545               if (BV (clib_bihash_is_free) (&v->kvp[k]))
 546                 {
 547                   if (verbose > 1)
 548                     s = format (s, "    %d: empty\n",
 549                                 j * BIHASH_KVP_PER_PAGE + k);
 550                   continue;
 551                 }
 552               if (verbose)
 553                 {
 554                   s = format (s, "    %d: %U\n",
 555                               j * BIHASH_KVP_PER_PAGE + k,
 556                               BV (format_bihash_kvp), &(v->kvp[k]));
 557                 }
 558               active_elements++;
 559             }
 560           v++;
 561         }
 562     }
 563
 564   s = format (s, "    %lld active elements\n", active_elements);
 565   s = format (s, "    %d free lists\n", vec_len (h->freelists));
 566   s = format (s, "    %d linear search buckets\n", h->linear_buckets);
 567   s = format (s, "    %lld cache hits, %lld cache misses\n",
 568               h->cache_hits, h->cache_misses);
 569   return s;
 570 }
 571
 572 void BV (clib_bihash_foreach_key_value_pair)
 573   (BVT (clib_bihash) * h, void *callback, void *arg)
 574 {
 575   int i, j, k;
 576   BVT (clib_bihash_bucket) * b;
 577   BVT (clib_bihash_value) * v;
 578   void (*fp) (BVT (clib_bihash_kv) *, void *) = callback;
 579
 580   for (i = 0; i < h->nbuckets; i++)
 581     {
 582       b = &h->buckets[i];
 583       if (b->offset == 0)
 584         continue;
 585
 586       v = BV (clib_bihash_get_value) (h, b->offset);
 587       for (j = 0; j < (1 << b->log2_pages); j++)
 588         {
 589           for (k = 0; k < BIHASH_KVP_PER_PAGE; k++)
 590             {
 591               if (BV (clib_bihash_is_free) (&v->kvp[k]))
 592                 continue;
 593
 594               (*fp) (&v->kvp[k], arg);
 595             }
 596           v++;
 597         }
 598     }
 599 }
 600
 601 /** @endcond */
 602
 603 /*
 604  * fd.io coding-style-patch-verification: ON
 605  *
 606  * Local Variables:
 607  * eval: (c-set-style "gnu")
 608  * End:
 609  */