Add monotonicity

Author: slashdotted

CMakeLists.txt

@@ -30,38 +30,48 @@ add_executable(speed_test speed_test.cpp
     vcpkg.json
     memento/memento.h
     memento/mementoengine.h
-    memento/mementoneengine.h
     anchor/AnchorHashQre.cpp anchor/AnchorHashQre.hpp  anchor/misc/crc32c_sse42_u64.h
     anchor/anchorengine.h
     memento/mashtable.h
     jump/jumpengine.h
     power/powerengine.h
-    memento/mementoneshortcutengine.h
     )
 
 add_executable(balance balance.cpp
     vcpkg.json
     memento/memento.h
     memento/mementoengine.h
-    memento/mementoneengine.h
     anchor/AnchorHashQre.cpp anchor/AnchorHashQre.hpp  anchor/misc/crc32c_sse42_u64.h
     anchor/anchorengine.h
     memento/mashtable.h
     jump/jumpengine.h
     power/powerengine.h
-    memento/mementoneshortcutengine.h
+    )
+
+add_executable(monotonicity monotonicity.cpp
+    vcpkg.json
+    memento/memento.h
+    memento/mementoengine.h
+    anchor/AnchorHashQre.cpp anchor/AnchorHashQre.hpp  anchor/misc/crc32c_sse42_u64.h
+    anchor/anchorengine.h
+    memento/mashtable.h
+    jump/jumpengine.h
+    power/powerengine.h
     )
 
 add_executable(mashtable_test mashtable_test.cpp memento/mashtable.h)
 
 if(WITH_PCG32)
     target_include_directories(speed_test PRIVATE ${PCG_INCLUDE_DIRS})
     target_include_directories(balance PRIVATE ${PCG_INCLUDE_DIRS})
+    target_include_directories(monotonicity PRIVATE ${PCG_INCLUDE_DIRS})
 endif()
 target_include_directories(speed_test PRIVATE ${GTL_INCLUDE_DIRS})
 target_include_directories(balance PRIVATE ${GTL_INCLUDE_DIRS})
+target_include_directories(monotonicity PRIVATE ${GTL_INCLUDE_DIRS})
 target_link_libraries(speed_test PRIVATE xxHash::xxhash fmt::fmt cxxopts::cxxopts)
 target_link_libraries(balance PRIVATE xxHash::xxhash fmt::fmt cxxopts::cxxopts)
+target_link_libraries(monotonicity PRIVATE xxHash::xxhash fmt::fmt cxxopts::cxxopts)
 include(GNUInstallDirs)
 install(TARGETS speed_test
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -72,3 +82,8 @@ install(TARGETS balance
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
+
+install(TARGETS monotonicity
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)

README.md

@@ -4,11 +4,12 @@ This project collects C++ implementations and benchmarking tools of some of the
 The implemented algorithms are:
 * [2014] __jump hash__ by [Lamping and Veach](https://arxiv.org/pdf/1406.2294.pdf)
 * [2020] __anchor hash__ by [Gal Mendelson et al.](https://arxiv.org/pdf/1812.09674.pdf), using the implementation found on [Github](https://github.com/anchorhash/cpp-anchorhash)
+* [2023] __power consistent hash__ by [Eric Leu](https://arxiv.org/pdf/2307.12448.pdf)
 * [2023] __memento hash__ by [M. Coluzzi et al.](https://arxiv.org/pdf/2306.09783.pdf)
 
 ## Benchmarks
 
-The project includes a two benchmarking tools **speed_test** and **balance**, derived from the same tools provided by [Anchorhash](https://github.com/anchorhash/cpp-anchorhash)
+The project includes three benchmarking tools **speed_test**, **balance**, and **monotonicity** derived from the same tools provided by [Anchorhash](https://github.com/anchorhash/cpp-anchorhash)
 
 **speed_test** also records **heap allocations** and the maximum allocated heap space.
 
@@ -41,7 +42,7 @@ The **speed_test** benchmark performs several random key lookups, the syntax is:
 ./speed_test Algorithm AnchorSet WorkingSet NumRemovals Numkeys ResFilename
 ```
 where
- * **Algorithm** can be *memento* (for MementoHash using *boost::unordered_flat_map* for the removal set), *mementoboost* (for MementoHash using *boost::unordered_map* for the removal set), *mementostd* (for MementoHash using *std::unordered_map* for the removal set), *mementomash* (for MementoHash using a hash table similar to Java's HashMap), *anchor* (for AnchorHash), *mementogtl* (for Memento with gtl hash map), *jump* (for JumpHash)
+ * **Algorithm** can be *memento* (for MementoHash using *boost::unordered_flat_map* for the removal set), *mementoboost* (for MementoHash using *boost::unordered_map* for the removal set), *mementostd* (for MementoHash using *std::unordered_map* for the removal set), *mementomash* (for MementoHash using a hash table similar to Java's HashMap), *anchor* (for AnchorHash), *mementogtl* (for Memento with gtl hash map), *jump* (for JumpHash), *power* (for Power Consistent Hashing)
  * **AnchorSet** is the size of the Anchor set (**a**): this parameter is used only by *anchor* but must be set to a value *at least equal to WorkingSet* even with *MementoHash*;
  * **WorkingSet** is the size of the initial Working set (**w**);
  * **NumRemovals** is the number of nodes that should be removed (randomly, except for *Jump*) before starting the benchmark;
@@ -65,6 +66,17 @@ The **balance** benchmark performs a balance test and accepts the same parameter
 Algorithm: memento, AnchorSet: 1000000, WorkingSet: 1000000, NumRemovals: 20000, NumKeys: 1000000, ResFileName: memento.txt
 Memento<boost::unordered_flat_map>: LB is 8.82
 ```
+The **monotonicity** benchmark performs a monotonicity test and accepts the same parameters as **speed_test**. Example:
+
+```bash
+./monotonicity memento 1000000 1000000 1000 1000000 memento.txt
+Algorithm: memento, AnchorSet: 1000000, WorkingSet: 1000000, NumRemovals: 1000, NumKeys: 1000000, ResFileName: memento.txt
+Done determining initial assignment of 1000000 unique keys
+Removed node 424868
+Memento<boost::unordered_flat_map>: after removal misplaced keys are 0% (0 keys out of 1000000)
+Added node 424868
+Memento<boost::unordered_flat_map>: after adding back misplaced keys are 0% (0 keys out of 1000000)
+```
 
 ## Java implementation
 For a Java implementation of these and additional algorithms please refer to [this repository](https://github.com/SUPSI-DTI-ISIN/java-consistent-hashing-algorithms)

balance.cpp

@@ -26,8 +26,6 @@
 #include "memento/mementoengine.h"
 #include "jump/jumpengine.h"
 #include "power/powerengine.h"
-#include "memento/mementoneengine.h"
-#include "memento/mementoneshortcutengine.h"
 #include <fmt/core.h>
 #include <fstream>
 #include <unordered_map>
@@ -131,7 +129,7 @@ int main(int argc, char *argv[]) {
   cxxopts::Options options("speed_test", "MementoHash vs AnchorHash benchmark");
   options.add_options()(
       "Algorithm",
-      "Algorithm (null|baseline|anchor|memento|mementoboost|mementomash|mementostd|mementogtl|jump|power|mementone)",
+      "Algorithm (null|baseline|anchor|memento|mementoboost|mementomash|mementostd|mementogtl|jump|power)",
       cxxopts::value<std::string>())(
       "AnchorSet", "Size of the AnchorSet (ignored by Memento)",
       cxxopts::value<int>())("WorkingSet", "Size of the WorkingSet",
@@ -214,14 +212,6 @@ int main(int argc, char *argv[]) {
       return bench<PowerEngine>("PowerEngine", filename,
                                anchor_set, working_set,
                                num_removals, num_keys);
-  } else if (algorithm == "mementone") {
-      return bench<MementoneEngine<boost::unordered_flat_map>>(
-          "Mementone<boost::unordered_flat_map>", filename, anchor_set, working_set,
-          num_removals, num_keys);
-  } else if (algorithm == "mementoneshortcut") {
-      return bench<MementoneShortcutEngine>(
-          "MementoneShortcutEngine", filename, anchor_set, working_set,
-          num_removals, num_keys);
   } else {
     fmt::println("Unknown algorithm {}", algorithm);
     return 2;

memento/mashtable.h

@@ -27,20 +27,20 @@ template <Integral K, typename V> class MashTable final {
   static constexpr uint32_t MIN_TABLE_SIZE = 1 << 4;
   static constexpr uint32_t MAX_TABLE_SIZE = 1 << 30;
 
-  struct Entry final {
+  struct Item final {
     K m_key;
     V m_value;
-    Entry *m_next;
+    Item *m_next;
 
-    Entry(K key, V value, Entry *next = nullptr)
+    Item(K key, V value, Item *next = nullptr)
         : m_key{key}, m_value{value}, m_next{next} {}
   };
 
-  Entry **m_table;
+  Item **m_table;
   uint32_t m_length;
   uint32_t m_size;
 
-  void add(Entry *entry, Entry **table, uint32_t table_length) {
+  void add(Item *entry, Item **table, uint32_t table_length) {
     auto kint{static_cast<unsigned int>(entry->m_key)};
     unsigned int hash = kint ^ kint >> 16;
     unsigned int index = (table_length - 1) & hash;
@@ -53,7 +53,7 @@ template <Integral K, typename V> class MashTable final {
       return;
     if (newTableSize > m_length && m_length >= MAX_TABLE_SIZE)
       return;
-    auto newTable{new Entry *[newTableSize]()};
+    auto newTable{new Item *[newTableSize]()};
     for (unsigned int i{0}; i < m_length; ++i) {
       auto entry{m_table[i]};
       while (entry) {
@@ -78,7 +78,7 @@ template <Integral K, typename V> class MashTable final {
     if (!entry) {
       return;
     }
-    Entry *prev{nullptr};
+    Item *prev{nullptr};
     while (entry && entry->m_key != key) {
       prev = entry;
       entry = entry->m_next;
@@ -96,7 +96,7 @@ template <Integral K, typename V> class MashTable final {
     delete entry;
   }
 
-  void doFree(Entry** t, uint32_t s) {
+  void doFree(Item** t, uint32_t s) {
       for(unsigned int i{0}; i<s; ++i) {
           auto e{t[i]};
           while(e) {
@@ -111,11 +111,11 @@ template <Integral K, typename V> class MashTable final {
 public:
   struct iterator final {
       iterator() : m_pair{nullptr, V()} {}
-    iterator(Entry *e) : m_pair{e, e->m_value} {}
-    std::pair<Entry *, V> m_pair;
+    iterator(Item *e) : m_pair{e, e->m_value} {}
+    std::pair<Item *, V> m_pair;
 
-    const std::pair<Entry *, V> &operator*() const noexcept { return m_pair; }
-    std::pair<Entry *, V> *operator->() noexcept { return &m_pair; }
+    const std::pair<Item *, V> &operator*() const noexcept { return m_pair; }
+    std::pair<Item *, V> *operator->() noexcept { return &m_pair; }
     bool operator==(const iterator &o) const noexcept {
       return m_pair.first == o.m_pair.first;
     }
@@ -125,7 +125,7 @@ template <Integral K, typename V> class MashTable final {
   };
 
   MashTable()
-      : m_table{new Entry *[MIN_TABLE_SIZE]()}, m_length{MIN_TABLE_SIZE},
+      : m_table{new Item *[MIN_TABLE_SIZE]()}, m_length{MIN_TABLE_SIZE},
         m_size{0} {}
 
   ~MashTable() noexcept {
@@ -136,7 +136,7 @@ template <Integral K, typename V> class MashTable final {
   MashTable& operator=(const MashTable&) = delete;
 
   int emplace(const K &key, V &&value) noexcept {
-    Entry *entry{new Entry{key, std::move(value)}};
+    Item *entry{new Item{key, std::move(value)}};
     add(entry, m_table, m_length);
     ++m_size;
     if (m_size > capacity()) {
@@ -164,8 +164,8 @@ template <Integral K, typename V> class MashTable final {
   }
 
   void erase(const iterator &it) {
-    if (it.e) {
-      remove(it.e->m_key);
+    if (it.m_pair.first) {
+          remove(it.m_pair.first->m_key);
       --m_size;
       if (m_size <= capacity() >> 2)
         resizeTable(m_length >> 1);

memento/memento.h

@@ -78,8 +78,9 @@ class Memento final
             return bucket + 1;
         }
         auto e = m_table.find(bucket);
+        auto ret{e->second.prevRemoved};
         m_table.erase(e);
-        return e->second.prevRemoved;
+        return ret;
     }
 
     /**