[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 (egmkang@gmail.com)

#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实在是太繁琐了.