fdsdump: abstract away hash table choice

Author: sedmicha

src/tools/fdsdump/src/aggregator/CMakeLists.txt

@@ -3,7 +3,7 @@ set(AGGREGATOR_SRC
     mode.cpp
     aggregator.cpp
     arenaAllocator.cpp
-    hashTable.cpp
+    fastHashTable.cpp
     view.cpp
     sort.cpp
     print.cpp

…ols/fdsdump/src/aggregator/hashTable.cpp …fdsdump/src/aggregator/fastHashTable.cppsrc/tools/fdsdump/src/aggregator/hashTable.cpp renamed to src/tools/fdsdump/src/aggregator/fastHashTable.cpp src/tools/fdsdump/src/aggregator/hashTable.cpp renamed to src/tools/fdsdump/src/aggregator/fastHashTable.cpp

@@ -4,11 +4,13 @@
  * @brief Efficient hash table implementation
  */
 
+#ifdef __SSE2__
+
 #define XXH_INLINE_ALL
 
 #include <xmmintrin.h>
 
-#include "hashTable.hpp"
+#include "fastHashTable.hpp"
 #include "3rd_party/xxhash/xxhash.h"
 
 namespace fdsdump {
@@ -18,14 +20,14 @@ static constexpr double EXPAND_WHEN_THIS_FULL = 0.95;
 static constexpr unsigned int EXPAND_WITH_FACTOR_OF = 2;
 static constexpr uint8_t EMPTY_BIT = 0x80;
 
-HashTable::HashTable(std::size_t key_size, std::size_t value_size) :
+FastHashTable::FastHashTable(std::size_t key_size, std::size_t value_size) :
     m_key_size(key_size), m_value_size(value_size)
 {
     init_blocks();
 }
 
 void
-HashTable::init_blocks()
+FastHashTable::init_blocks()
 {
     HashTableBlock zeroed_block;
 
@@ -41,7 +43,7 @@ HashTable::init_blocks()
 }
 
 bool
-HashTable::lookup(uint8_t *key, uint8_t *&item, bool create_if_not_found)
+FastHashTable::lookup(uint8_t *key, uint8_t *&item, bool create_if_not_found)
 {
     uint64_t hash = XXH3_64bits(key, m_key_size); // The hash of the key
     uint64_t index = (hash >> 7) & (m_block_count - 1); // The starting block index
@@ -109,7 +111,7 @@ HashTable::lookup(uint8_t *key, uint8_t *&item, bool create_if_not_found)
 }
 
 void
-HashTable::expand()
+FastHashTable::expand()
 {
     // Grow the amount of blocks by a specified factor
     m_block_count *= EXPAND_WITH_FACTOR_OF;
@@ -144,16 +146,18 @@ HashTable::expand()
 }
 
 bool
-HashTable::find(uint8_t *key, uint8_t *&item)
+FastHashTable::find(uint8_t *key, uint8_t *&item)
 {
     return lookup(key, item, false);
 }
 
 bool
-HashTable::find_or_create(uint8_t *key, uint8_t *&item)
+FastHashTable::find_or_create(uint8_t *key, uint8_t *&item)
 {
     return lookup(key, item, true);
 }
 
 } // aggregator
 } // fdsdump
+
+#endif // ifdef __SSE2__

src/tools/fdsdump/src/aggregator/fastHashTable.hpp

@@ -0,0 +1,93 @@
+/**
+ * @file
+ * @author Michal Sedlak <[email protected]>
+ * @brief Efficient hash table implementation
+ */
+#pragma once
+
+#ifdef __SSE2__
+
+#include <aggregator/arenaAllocator.hpp>
+
+#include <cstdint>
+#include <vector>
+
+namespace fdsdump {
+namespace aggregator {
+
+/**
+ * @brief A struct representing a hash table block.
+ */
+struct HashTableBlock
+{
+    alignas(16) uint8_t tags[16];
+    uint8_t *items[16];
+};
+
+/**
+ * @brief An efficient hash table implementation inspired by a family of hash
+ * tables known as "Swiss tables".
+ */
+class FastHashTable {
+public:
+    /**
+     * @brief Constructs a new instance.
+     * @param[in]  key_size    Number of bytes of the key portion of the record
+     * @param[in]  value_size  Number of bytes of the value portion of the record
+     */
+    FastHashTable(std::size_t key_size, std::size_t value_size);
+
+    /**
+     * @brief Find a record corresponding to the provided key
+     * @param key   The key
+     * @param item  The stored record including the key
+     * @return true if the record was found, false otherwise
+     */
+    bool
+    find(uint8_t *key, uint8_t *&item);
+
+    /**
+     * @brief Find a record corresponding to the provided key or create a new
+     *   one if not found.
+     * @param key   The key
+     * @param item  The stored record including the key
+     * @return true if the record was found, false if it wasn't and a new record
+     *   was created
+     */
+    bool
+    find_or_create(uint8_t *key, uint8_t *&item);
+
+    /**
+     * @brief Access the stored records.
+     * @warning
+     *   If the vector is modified bu the caller in some way, the behavior of
+     *   following calls to the hash table methods are undefined
+     * @return Vector of the stored records
+     */
+    std::vector<uint8_t *> &items() { return m_items; }
+
+private:
+    std::size_t m_block_count = 4096;
+    std::size_t m_record_count = 0;
+    std::size_t m_key_size;
+    std::size_t m_value_size;
+
+    std::vector<HashTableBlock> m_blocks;
+    std::vector<uint8_t *> m_items;
+
+    ArenaAllocator m_allocator;
+
+    bool
+    lookup(uint8_t *key, uint8_t *&item, bool create_if_not_found);
+
+    void
+    init_blocks();
+
+    void
+    expand();
+};
+
+} // aggregator
+} // fdsdump
+
+#endif // ifdef __SSE2__ 

src/tools/fdsdump/src/aggregator/hashTable.hpp

@@ -1,89 +1,33 @@
 /**
  * @file
- * @author Michal Sedlak <[email protected].cz>
- * @brief Efficient hash table implementation
+ * @author Michal Sedlak <sedlakm@cesnet.cz>
+ * @brief Select hash table implementation
  */
+
 #pragma once
 
-#include <cstdint>
-#include <vector>
+#if defined(__SSE2__) && !defined(FDSDUMP_USE_STD_HASHTABLE)
 
-#include "arenaAllocator.hpp"
+#include <aggregator/fastHashTable.hpp>
 
 namespace fdsdump {
 namespace aggregator {
 
-/**
- * @brief A struct representing a hash table block.
- */
-struct HashTableBlock
-{
-    alignas(16) uint8_t tags[16];
-    uint8_t *items[16];
-};
-
-/**
- * @brief An efficient hash table implementation inspired by a family of hash
- * tables known as "Swiss tables".
- */
-class HashTable {
-public:
-    /**
-     * @brief Constructs a new instance.
-     * @param[in]  key_size    Number of bytes of the key portion of the record
-     * @param[in]  value_size  Number of bytes of the value portion of the record
-     */
-    HashTable(std::size_t key_size, std::size_t value_size);
-
-    /**
-     * @brief Find a record corresponding to the provided key
-     * @param key   The key
-     * @param item  The stored record including the key
-     * @return true if the record was found, false otherwise
-     */
-    bool
-    find(uint8_t *key, uint8_t *&item);
-
-    /**
-     * @brief Find a record corresponding to the provided key or create a new
-     *   one if not found.
-     * @param key   The key
-     * @param item  The stored record including the key
-     * @return true if the record was found, false if it wasn't and a new record
-     *   was created
-     */
-    bool
-    find_or_create(uint8_t *key, uint8_t *&item);
+using HashTable = FastHashTable;
 
-    /**
-     * @brief Access the stored records.
-     * @warning
-     *   If the vector is modified bu the caller in some way, the behavior of
-     *   following calls to the hash table methods are undefined
-     * @return Vector of the stored records
-     */
-    std::vector<uint8_t *> &items() { return m_items; }
-
-private:
-    std::size_t m_block_count = 4096;
-    std::size_t m_record_count = 0;
-    std::size_t m_key_size;
-    std::size_t m_value_size;
-
-    std::vector<HashTableBlock> m_blocks;
-    std::vector<uint8_t *> m_items;
+} // aggregator
+} // fdsdump
 
-    ArenaAllocator m_allocator;
+#else
 
-    bool
-    lookup(uint8_t *key, uint8_t *&item, bool create_if_not_found);
+#include <aggregator/stdHashTable.hpp>
 
-    void
-    init_blocks();
+namespace fdsdump {
+namespace aggregator {
 
-    void
-    expand();
-};
+using HashTable = StdHashTable;
 
 } // aggregator
 } // fdsdump
+
+#endif