text: /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   * Junior University
   *
   * We are making the OpenFlow specification and associated documentation
   * (Software) available for public use and benefit with the expectation
   * that others will use, modify and enhance the Software and contribute
   * those enhancements back to the community. However, since we would
   * like to make the Software available for broadest use, with as few
   * restrictions as possible permission is hereby granted, free of
   * charge, to any person obtaining a copy of this Software to deal in
   * the Software under the copyrights without restriction, including
   * without limitation the rights to use, copy, modify, merge, publish,
   * distribute, sublicense, and/or sell copies of the Software, and to
   * permit persons to whom the Software is furnished to do so, subject to
   * the following conditions:
   *
   * The above copyright notice and this permission notice shall be
   * included in all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   * SOFTWARE.
   *
   * The name and trademarks of copyright holder(s) may NOT be used in
   * advertising or publicity pertaining to the Software or any
   * derivatives without specific, written prior permission.
   */
  
  #include <config.h>
  #include "hmap.h"
  #include <assert.h>
  #include <stdint.h>
  #include "util.h"
  
  /* Initializes 'hmap' as an empty hash table. */
  void
  hmap_init(struct hmap *hmap)
  {
      hmap->buckets = &hmap->one;
      hmap->one = NULL;
      hmap->mask = 0;
      hmap->n = 0;
  }
  
  /* Frees memory reserved by 'hmap'.  It is the client's responsibility to free
   * the nodes themselves, if necessary. */
  void
  hmap_destroy(struct hmap *hmap)
  {
      if (hmap && hmap->buckets != &hmap->one) {
          free(hmap->buckets);
      }
  }
  
  /* Exchanges hash maps 'a' and 'b'. */
  void
  hmap_swap(struct hmap *a, struct hmap *b)
  {
      struct hmap tmp = *a;
      *a = *b;
      *b = tmp;
      if (a->buckets == &b->one) {
          a->buckets = &a->one;
      }
      if (b->buckets == &a->one) {
          b->buckets = &b->one;
      }
  }
  
  static void
  resize(struct hmap *hmap, size_t new_mask)
  {
      struct hmap tmp;
      size_t i;
  
      assert(!(new_mask & (new_mask + 1)));
      assert(new_mask != SIZE_MAX);
  
      hmap_init(&tmp);
      if (new_mask) {
          tmp.buckets = xmalloc(sizeof *tmp.buckets * (new_mask + 1));
          tmp.mask = new_mask;
          for (i = 0; i <= tmp.mask; i++) {
              tmp.buckets[i] = NULL;
          }
      }
      for (i = 0; i <= hmap->mask; i++) {
          struct hmap_node *node, *next;
          for (node = hmap->buckets[i]; node; node = next) {
              next = node->next;
              hmap_insert_fast(&tmp, node, node->hash);
          }
      }
      hmap_swap(hmap, &tmp);
      hmap_destroy(&tmp);
  }
  
  static size_t
  calc_mask(size_t capacity)
  {
      size_t mask = capacity / 2;
      mask |= mask >> 1;
      mask |= mask >> 2;
      mask |= mask >> 4;
      mask |= mask >> 8;
      mask |= mask >> 16;
  #if SIZE_MAX > UINT32_MAX
      mask |= mask >> 32;
  #endif
  
      /* If we need to dynamically allocate buckets we might as well allocate at
       * least 4 of them. */
      mask |= (mask & 1) << 1;
  
      return mask;
  }
  
  /* Expands 'hmap', if necessary, to optimize the performance of searches. */
  void
  hmap_expand(struct hmap *hmap)
  {
      size_t new_mask = calc_mask(hmap->n);
      if (new_mask > hmap->mask) {
          resize(hmap, new_mask);
      }
  }
  
  /* Shrinks 'hmap', if necessary, to optimize the performance of iteration. */
  void
  hmap_shrink(struct hmap *hmap)
  {
      size_t new_mask = calc_mask(hmap->n);
      if (new_mask < hmap->mask) {
          resize(hmap, new_mask);
      }
  }
  
  void hmap_remove_and_shrink(struct hmap *hmap, struct hmap_node *node){
      hmap_remove(hmap, node);
      //hmap_shrink(hmap);
  }
  
  /* Expands 'hmap', if necessary, to optimize the performance of searches when
   * it has up to 'n' elements.  (But iteration will be slow in a hash map whose
   * allocated capacity is much higher than its current number of nodes.)  */
  void
  hmap_reserve(struct hmap *hmap, size_t n)
  {
      size_t new_mask = calc_mask(n);
      if (new_mask > hmap->mask) {
          resize(hmap, new_mask);
      }
  }
  