Initial commit

Author: rigtorp

.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: LLVM

.dir-locals.el

@@ -0,0 +1,3 @@
+((c++-mode (eval add-hook 'before-save-hook #'clang-format-buffer nil t))
+ (nil . ((compile-command . "cmake --build build")))
+)

.gitignore

@@ -0,0 +1,2 @@
+build
+*~

.projectile

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.2)    
+project(HashMap)
+
+set(CMAKE_CXX_FLAGS "-std=c++14 -Wall")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+
+add_executable(benchmark benchmark.cpp)

CMakeLists.txt

@@ -0,0 +1,262 @@
+/*
+Copyright (c) 2015 Erik Rigtorp <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software 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.
+ */
+
+/*
+HashMap
+
+A high performance hash map. Uses open addressing with linear
+probing.
+
+Advantages:
+  - Predictable performance. Doesn't use the allocator unless load factor
+    grows beyond 50%. Linear probing ensures cash efficency.
+  - Deletes items by rearranging items and marking slots as empty instead of
+    marking items as deleted. This is keeps performance high when there
+    is a high rate of churn (many paired inserts and deletes) since otherwise
+    most slots would be marked deleted and probing would end up scanning
+    most of the table.
+
+Disadvantages:
+  - Significant performance degradation at high load factors.
+  - Maximum load factor hard coded to 50%, memory inefficient.
+  - Memory is not reclaimed on erase.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <vector>
+
+template <typename Key, typename T, typename Hash = std::hash<Key>>
+class HashMap {
+public:
+  using key_type = Key;
+  using mapped_type = T;
+  using value_type = std::pair<Key, T>;
+  using size_type = std::size_t;
+  using hasher = Hash;
+  using reference = value_type &;
+  using const_reference = const value_type &;
+  using buckets = std::vector<value_type>;
+
+  template <typename ContT, typename IterVal> struct hm_iterator {
+    using value_type = IterVal;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::forward_iterator_tag;
+
+    bool operator==(const hm_iterator &other) const {
+      return other.hm_ == hm_ && other.idx_ == idx_;
+    }
+    bool operator!=(const hm_iterator &other) { return !(other == *this); }
+
+    hm_iterator &operator++() {
+      ++idx_;
+      advance_past_empty();
+      return *this;
+    }
+
+    reference operator*() const { return hm_->buckets_[idx_]; }
+    pointer operator->() const { return &hm_->buckets_[idx_]; }
+
+  private:
+    explicit hm_iterator(ContT *hm) : hm_(hm) { advance_past_empty(); }
+    explicit hm_iterator(ContT *hm, size_type idx) : hm_(hm), idx_(idx) {}
+
+    void advance_past_empty() {
+      while (idx_ < hm_->buckets_.size() &&
+             hm_->buckets_[idx_].first == hm_->empty_key_) {
+        ++idx_;
+      }
+    }
+
+    ContT *hm_ = nullptr;
+    typename ContT::size_type idx_ = 0;
+    friend ContT;
+  };
+
+  using iterator = hm_iterator<HashMap, value_type>;
+  using const_iterator = hm_iterator<const HashMap, const value_type>;
+
+public:
+  HashMap(size_type bucket_count, key_type empty_key) : empty_key_(empty_key) {
+    size_t pow2 = 1;
+    while (pow2 < bucket_count) {
+      pow2 <<= 1;
+    }
+    buckets_.resize(pow2, std::make_pair(empty_key_, T()));
+  }
+
+  HashMap(const HashMap &other, size_type bucket_count)
+      : HashMap(bucket_count, other.empty_key_) {
+    for (auto it = other.begin(); it != other.end(); ++it) {
+      insert(*it);
+    }
+  }
+
+  // Iterators
+  iterator begin() { return iterator(this); }
+
+  const_iterator begin() const { return const_iterator(this); }
+
+  iterator end() { return iterator(this, buckets_.size()); }
+
+  const_iterator end() const { return const_iterator(this, buckets_.size()); }
+
+  // Capacity
+  bool empty() const { return size() == 0; }
+  size_type size() const { return size_; }
+  size_type max_size() const { return std::numeric_limits<size_type>::max(); }
+
+  // Modifiers
+  void clear() {
+    for (auto it = begin(); it != end(); ++it) {
+      it->first = empty_key_;
+    }
+  }
+
+  std::pair<iterator, bool> insert(const value_type &value) {
+    return emplace(value.first, value.second);
+  };
+
+  std::pair<iterator, bool> insert(value_type &&value) {
+    return emplace(value.first, std::move(value.second));
+  };
+
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(key_type key, Args &&... args) {
+    reserve(size_ + 1);
+    for (size_t idx = key_to_idx(key);; idx = probe_next(idx)) {
+      if (buckets_[idx].first == empty_key_) {
+        buckets_[idx].second = mapped_type(std::forward<Args>(args)...);
+        buckets_[idx].first = key;
+        size_++;
+        return std::make_pair(iterator(this, idx), true);
+      } else if (buckets_[idx].first == key) {
+        return std::make_pair(iterator(this, idx), false);
+      }
+    }
+  };
+
+  void erase(iterator it) {
+    size_t bucket = it.idx_;
+    for (size_t idx = probe_next(bucket);; idx = probe_next(idx)) {
+      if (buckets_[idx].first == empty_key_) {
+        buckets_[bucket].first = empty_key_;
+        size_--;
+        return;
+      }
+      size_t ideal = key_to_idx(buckets_[idx].first);
+      if (diff(bucket, ideal) < diff(idx, ideal)) {
+        // swap, bucket is closer to ideal than idx
+        buckets_[bucket] = buckets_[idx];
+        bucket = idx;
+      }
+    }
+  }
+
+  size_type erase(const key_type key) {
+    auto it = find(key);
+    if (it != end()) {
+      erase(it);
+      return 1;
+    }
+    return 0;
+  }
+
+  void swap(HashMap &other) {
+    std::swap(buckets_, other.buckets_);
+    std::swap(size_, other.size_);
+    std::swap(empty_key_, other.empty_key_);
+  }
+
+  // Lookup
+  reference at(key_type key) {
+    iterator it = find(key);
+    if (it != end()) {
+      return it->second;
+    }
+    throw std::out_of_range();
+  }
+
+  const_reference at(key_type key) const { return at(key); }
+
+  size_type count(key_type key) const { return find(key) == end() ? 0 : 1; }
+
+  iterator find(key_type key) {
+    for (size_t idx = key_to_idx(key);; idx = probe_next(idx)) {
+      if (buckets_[idx].first == key) {
+        return iterator(this, idx);
+      }
+      if (buckets_[idx].first == empty_key_) {
+        return end();
+      }
+    }
+  }
+
+  const_iterator find(key_type key) const {
+    return const_cast<HashMap *>(this)->find(key);
+  }
+
+  // Bucket interface
+  size_type bucket_count() const { return buckets_.size(); }
+
+  // Hash policy
+  void rehash(size_type count) {
+    count = std::max(count, size() * 2);
+    HashMap other(*this, count);
+    swap(other);
+  }
+
+  void reserve(size_type count) {
+    if (count * 2 > buckets_.size()) {
+      HashMap other(*this, buckets_.size() * 2);
+      swap(other);
+    }
+  }
+
+  // Observers
+  hasher hash_function() const { return hasher(); }
+
+private:
+  inline size_t key_to_idx(key_type key) {
+    const size_t mask = buckets_.size() - 1;
+    return hasher()(key) & mask;
+  }
+
+  inline size_t probe_next(size_t idx) {
+    const size_t mask = buckets_.size() - 1;
+    return (idx + 1) & mask;
+  }
+
+  inline size_t diff(size_t a, size_t b) {
+    const size_t mask = buckets_.size() - 1;
+    return (buckets_.size() + (a - b)) & mask;
+  }
+
+  key_type empty_key_;
+  buckets buckets_;
+  size_t size_ = 0;
+};

HashMap.h

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Erik Rigtorp <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software 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.
+

LICENSE

@@ -0,0 +1,27 @@
+# HashMap.h
+
+A hash table mostly compatible with the C++11 *std::unordered_map*
+interface, but with much higher performance.
+
+This hash table uses open addressing with linear probing and backshift
+deletion. Open addressing and linear probing minimizes memory
+allocations and achives high cache effiency. Backshift deletion keeps
+performance high for delete heavy workloads by not clobbering the hash
+table with tombestones. 
+
+Please note that this hash table currently only works with POD-types,
+destructors are not called on *erase()*. It's not too hard to make it
+work with complex types.
+
+## Benchmark
+
+The benchmark first inserts 1M random entries in the table and then
+removes the last inserted item and inserts a new random entry 1
+billion times. This is benchmark is designed to simulate a delete
+heavy workload.
+
+```
+HashMap:                77 ns/iter
+google::dense_hash_map: 122 ns/iter
+std::unordered_map:     220 ns/iter
+```