[C++]怎么樣實現一個較快的Hash Table

　　我們服務器一直在用boost/sgl stl的hash table,但是從來沒有考慮過其中的效率問題,雖然hash_map/unordered_map跑的可能真的比map快一些,可能應該不是你理解的那么快.其實他可以更快一些!!!

　　當我自己嘗試着實現了一個hash table之后,我發現確實如此.這篇文章也是來說說,如何實現較快的一個.

　　通常的hash table都是用開鏈法,開放地址法來解決沖突.開鏈法是總容易實現的一個,而且因為效率穩定,被加入了C++11,取名unordered_map.不過效率實在不咋地.

　　開放地址法的hash table,我是從google-sparsehash里面注意到的,雖然數據結構,算法導論都會講到.網上說速度很快,我就去看了一下API,其比普通的unordered_map多了一組API:

1.  set_empty_key/set_deleted_key

　　在開鏈法中,所有的節點都是容器內的內容,可是開放地址法中不是的.所以需要額外的信息來維護節點的可用性信息.

　　當時我看到這兩個API,大概就猜到內存是怎么實現的,閑來無事就是試着寫了一個demo,在VC 2008下面跑的結果是,比unordered_map快一倍多;在Linux x64 gcc 4.4下面的結果是,比unordered_map快了將近1倍.

2. 高性能的hash table必須是開放地址法的

　　這么說,是有原因的.鏈表的特性就是容易刪除,容易插入.可是hash table不需要這些特性,hash table只需要快.可以鏈表這東西,偏偏做不到快速定位,雖然你知道有下一個節點,但是你不知道下一個節點的准確位置,經常會造成緩存未命中,浪費大量時間.

3. bucket的容量

　　bucket的容量也是影響hash table性能的一個因素.無數的數據結構和算法書籍,都教導大家,通過質數取余數,可以獲得比較好的下標分布.可是,無論是除法還是乘法,消耗都是相當高的.十幾個或者幾十個時鍾周期,始終比不上一兩個時鍾周期快.所以,高性能的hash table必須要把bucket的容量設置成2^n.google-sparsehash里面初始容量是32.擴容的話,都是直接左移;算下標的話,都是(容量-1) & hash_value,簡單的一個位運算搞定.

4. 正確實現find_position

　　我自己實現的hash table,是線性探測法的.所以find position也是比較簡單,就是通過hash value和掩碼,獲取到其實下標,然后一個一個test.需要把buckets當作是環形的,否則buckets最末位的數據沖突就會不好搞.(我當時沒有考慮這一點,直接給他擴容了.....)

5. 對象模型

　　不同的Key和Value模型,可以導致你對Hash Table的不同實現.簡單的說,在C里面,你可以不用考慮Key和Value的生命周期(:D),但是C++里面,你不得不考慮Key,Value的生命周期問題.你不能做一個假設,key和value都是簡單數據類型.一個int映射到一個對象,這種經常會用到的.

　　所以,erase一個key的時候,需要把key設置成deleted,然后還要把value重置一遍.如果沒有重置,對象所引用的內存有可能就會被泄露.

　　這引發了我另外一個想法,就是通過模板,來特化Value的reset行為.因為不是所有的Value都是需要被重置的,只有那些復雜對象,才需要.

6. 可以考慮緩沖hash value

　　如果key都是簡單數據,而非string或者復雜的數據類型,緩沖是沒有任何意義的,因為hash value可以被快速的計算出來;但是當key是char*,或者一些復雜的數據類型,緩沖就會變的有意義.而且緩沖更有利於重排,容器擴容的時候速度會更快一些.

7. 考慮使用C的內存分配器

　　盡量不要使用C++的new/delete來分配內存.new,delete會有對象的構造,析構過程,這可能不是你所希望的.針對key和value數據類型的不同,你可能會有自己的特有的構造,析構過程.而且,C的內存分配器,同樣可以被一些第三方庫優化,比如tcmalloc/jemalloc等.

8. 選一個好的Hash函數(這是最重要的)

9. 盡力防止拷貝

　　rehash非常耗時,如果支持C++11,就使用move操作;如果不支持,就用swap,否則會復制很多次.

 代碼貼上:

//Copyright 2012, egmkang wang.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of green_turtle nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// author: egmkang ([e-mail])

#ifndef __MY_HASH_TABLE__
#define __MY_HASH_TABLE__
#include <utility>
#include <functional>
#include <cstddef>
#include <stdlib.h>
namespace green_turtle{

//hash_table with linear probing
template<class Key,
        class T,
        class Hash = std::hash<Key>,
        class KeyEqual = std::equal_to<Key> >
class hash_map
{
 public:
  typedef Key key_type;
  typedef T mapped_type;
  typedef std::pair<const Key,T> value_type;
  typedef size_t size_type;
  typedef Hash hash_fn;
  typedef KeyEqual equal_fn;
  typedef value_type* iterator;

  hash_map(size_type capacity = 32,key_type empty = key_type(),key_type deleted = key_type()):
    empty_key_(empty)
    ,deleted_key_(deleted)
    ,size_(0)
    ,capacity_(capacity)
    ,buckets_(nullptr)
    ,hasher_()
    ,equaler_()
  {
    init_buckets();
  }
  ~hash_map()
  {
    delete_buckets();
  }
  hash_map(hash_map&& m,size_type capacity = 32):
      buckets_(nullptr)
  {
    empty_key_ = m.empty_key_;
    deleted_key_ = m.deleted_key_;
    size_ = 0;
    capacity_ = m.capacity_;
    //to impl the increase and decrease method
    if(capacity_ != capacity && capacity >= 32)
      capacity_ = capacity;
    hasher_ = m.hasher_;
    equaler_ = m.equaler_;

    init_buckets();

    copy_from(m);
  }
  hash_map& operator = (const hash_map& m)
  {
    empty_key_ = m.empty_key_;
    deleted_key_ = m.deleted_key_;
    size_ = 0;
    capacity_ = m.capacity_;
    hasher_ = m.hasher_;
    equaler_ = m.equaler_;

    init_buckets();

    copy_from(m);
  }
  void swap(hash_map& m)
  {
    std::swap(empty_key_ , m.empty_key_);
    std::swap(deleted_key_ , m.deleted_key_);
    std::swap(size_ , m.size_);
    std::swap(capacity_ , m.capacity_);
    std::swap(hasher_ , m.hasher_);
    std::swap(equaler_ , m.equaler_);
    std::swap(buckets_ , m.buckets_);
  }

  iterator end() { return nullptr; }
  iterator end() const { return nullptr; }

  iterator find(const key_type& key)
  {
    if(is_key_empty(key) || is_key_deleted(key))
      return NULL;
    iterator pair_ = find_position(key);
    if(!pair_ || !equaler_(key,pair_->first))
      return NULL;
    return pair_;
  }
  iterator find(const key_type& key) const
  {
    if(is_key_empty(key) || is_key_deleted(key))
      return NULL;
    iterator pair_ = find_position(key);
    if(!pair_ || !equaler_(key,pair_->first))
      return NULL;
    return pair_;
  }

  std::pair<iterator, bool> insert(const value_type& v)
  {
    std::pair<iterator, bool> result(nullptr, false);
    result.first = _insert(v);
    result.second = result.first ? true : false;
    return result;
  }

  template<class P>
  std::pair<iterator, bool> insert(P&& p)
  {
    std::pair<iterator, bool> result(nullptr, false);
    result.first = _insert(std::forward<P>(p));
    result.second = result.first ? true : false;
    return result;
  }

  template<class... Args>
  std::pair<iterator, bool> emplace(Args&&... args)
  {
    std::pair<iterator, bool> result(nullptr, false);
    value_type _v(std::forward<Args>(args)...);
    result.first = _insert(std::move(_v));
    result.second = result.first ? true : false;
    return result;
  }

  mapped_type& operator[](const key_type& key)
  {
    value_type *pair_ = find(key);
    if(!pair_)
    {
      pair_ = insert(std::make_pair(key,mapped_type()));
    }
    return pair_->second;
  }

  mapped_type& operator[](key_type&& key)
  {
    value_type *pair_ = find(key);
    if(!pair_)
    {
      pair_ = insert(std::make_pair(std::move(key), std::move(mapped_type())));
    }
    return pair_->second;
  }

  void erase(const key_type& key)
  {
    assert(empty_key_ != deleted_key_ && "you must set a deleted key value before delete it");
    value_type *pair = find(key);
    if(pair && equaler_(key,pair->first))
      set_key_deleted(pair);
    --size_;
    decrease_capacity();
  }
  void erase(const value_type* value)
  {
    if(value) erase(value->first);
  }
  void clear()
  {
    if(empty()) return;
    for(size_t idx = 0; idx < capacity_; ++idx)
    {
      buckets_[idx]->first = empty_key_;
      buckets_[idx]->second = mapped_type();
    }
    size_ = 0;
  }
  //bool (const value_type&);
  template<class Fn>
  void for_each(Fn f) const
  {
    if(empty()) return;
    for(size_t idx = 0; idx < capacity_; ++idx)
    {
      if(is_key_deleted(buckets_[idx].first) ||
         is_key_empty(buckets_[idx].first))
        continue;
      if(!f(buckets_[idx]))
        break;
    }
  }

  inline void set_deleted_key(key_type k)
  {
    assert(empty_key_ != k);
    if(deleted_key_ != empty_key_)
      assert(deleted_key_ == k);
    deleted_key_ = k;
  }
  inline bool empty() const { return size_ == 0; }
  inline size_type size() const { return size_; }
  inline size_type capacity() const { return capacity_; }
 private:
  //return key equal position
  //or first deleted postion
  //or empty postion
  value_type* find_position(const key_type& key) const
  {
    size_type hash_pair_ = hasher_(key);
    size_type mask_ = capacity_ - 1;
    size_type begin_ = hash_pair_ & mask_;
    size_type times_ = 0;
    value_type *first_deleted_ = NULL;
    while(true)
    {
      if(is_key_deleted(buckets_[begin_].first) && !first_deleted_)
        first_deleted_ = &buckets_[begin_];
      else if(is_key_empty(buckets_[begin_].first))
      {
        if(first_deleted_) return first_deleted_;
        return &buckets_[begin_];
      }
      else if(equaler_(key,buckets_[begin_].first))
        return &buckets_[begin_];

      begin_ = (begin_ + 1) & mask_;
      assert(times_++ <= capacity_);
      (void)times_;
    }
    return NULL;
  }
  void copy_from(hash_map&& m)
  {
    if(m.empty()) return;
    for(size_t idx = 0; idx < m.capacity_; ++idx)
    {
      if(is_key_deleted(m.buckets_[idx].first) ||
         is_key_empty(m.buckets_[idx].first))
        continue;
      _insert(std::move(m.buckets_[idx]));
    }
  }
  void copy_from(const hash_map& m)
  {
    if(m.empty()) return;
    for(size_t idx = 0; idx < m.capacity_; ++idx)
    {
      if(is_key_deleted(m.buckets_[idx].first) ||
         is_key_empty(m.buckets_[idx].first))
        continue;
      _insert(m.buckets_[idx]);
    }
  }
  void increase_capacity()
  {
    if(size_ > (capacity_ >> 1))
    {
      hash_map _m(std::move(*this),capacity_ << 1);
      swap(_m);
    }
  }
  void decrease_capacity()
  {
    if(size_ < (capacity_ >> 2))
    {
      hash_map _m(*this,capacity_ >> 2);
      swap(_m);
    }
  }
  void set_key_deleted(value_type& pair)
  {
      pair.first = deleted_key_;
      pair.second = mapped_type();
  }
  inline bool is_key_deleted(const key_type& key) const { return equaler_(key,deleted_key_); }
  inline bool is_key_empty(const key_type& key) const { return equaler_(key,empty_key_); }
  void init_buckets()
  {
    delete[] buckets_;
    buckets_ = new value_type[capacity_]();
    if(empty_key_ != key_type())
    {
      for(unsigned idx = 0; idx < capacity_; ++idx)
      {
        const_cast<key_type&>(buckets_[idx].first) = empty_key_;
      }
    }
  }
  void delete_buckets()
  {
    delete[] buckets_;
  }
  value_type* _insert(const value_type& _v)
  {
    const key_type& key = _v.first;
    if(is_key_deleted(key) || is_key_empty(key))
      return NULL;
    increase_capacity();
    value_type *pair_ = find_position(key);
    if(!pair_ || equaler_(key,pair_->first))
      return NULL;

    auto& k1 = const_cast<key_type&>(pair_->first);
    auto& v1 = const_cast<mapped_type&>(pair_->second);
    k1 = key;
    v1 = _v.second;

    ++size_;
    return pair_;
  }
  template<class P>
  value_type* _insert(P&& p)
  {
    std::pair<key_type, mapped_type> _v(p.first, p.second);
    const key_type& key = _v.first;
    if(is_key_deleted(key) || is_key_empty(key))
      return NULL;
    increase_capacity();
    value_type *pair_ = find_position(key);
    if(!pair_ || equaler_(key,pair_->first))
      return NULL;

    auto& k1 = const_cast<key_type&>(pair_->first);
    auto& v1 = const_cast<mapped_type&>(pair_->second);
    k1 = std::move(_v.first);
    v1 = std::move(_v.second);

    ++size_;
    return pair_;
  }
 private:
  key_type empty_key_;
  key_type deleted_key_;
  size_type size_;
  size_type capacity_;
  value_type *buckets_;
  hash_fn hasher_;
  equal_fn equaler_;
};

}//end namespace green_turtle
#endif//__MY_HASH_TABLE__

參考:

1. 算法導論

2. 計算機程序設計藝術

3. google-sparsehash dense_hash_map的實現, http://code.google.com/p/google-sparsehash

PS:

如果有一個好的內存分配器,STL的開鏈法hash table性能並不差太多,所以我砍掉了自己實現的hash table,代碼貼在上面.加入了C++11的move語義,可能會有一些bug,move實在是太繁瑣了.