fdsdump: add StdHashTable component

Author: sedmicha

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

@@ -10,6 +10,7 @@ set(AGGREGATOR_SRC
     printer.cpp
     jsonPrinter.cpp
     tablePrinter.cpp
+    stdHashTable.cpp
     stdAllocator.cpp
 )
 

src/tools/fdsdump/src/aggregator/stdHashTable.cpp

@@ -0,0 +1,59 @@
+/**
+ * @file
+ * @author Michal Sedlak <[email protected]>
+ * @brief Efficient hash table implementation
+ */
+
+#define XXH_INLINE_ALL
+
+#include "stdHashTable.hpp"
+#include <cstring>
+#include "3rd_party/xxhash/xxhash.h"
+
+namespace fdsdump {
+namespace aggregator {
+
+StdHashTable::StdHashTable(std::size_t key_size, std::size_t value_size) :
+    m_key_size(key_size),
+    m_value_size(value_size)
+{
+    auto hash = [=](const uint8_t *key) {
+        return XXH3_64bits(key, m_key_size);
+    };
+    auto equals = [=](const uint8_t *a, const uint8_t *b) {
+        return std::memcmp(a, b, m_key_size) == 0;
+    };
+    m_map = Map(1, hash, equals);
+}
+
+bool
+StdHashTable::find(uint8_t *key, uint8_t *&item)
+{
+    auto it = m_map.find(key);
+    if (it != m_map.end()) {
+        item = it->second;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool
+StdHashTable::find_or_create(uint8_t *key, uint8_t *&item)
+{
+    auto it = m_map.find(key);
+    if (it != m_map.end()) {
+        item = it->second;
+        return true;
+    } else {
+        uint8_t *data = m_allocator.allocate(m_key_size + m_value_size);
+        std::memcpy(data, key, m_key_size);
+        m_map.insert({data, data});
+        m_items.push_back(data);
+        item = data;
+        return false;
+    }
+}
+
+} // aggregator
+} // fdsdump

src/tools/fdsdump/src/aggregator/stdHashTable.hpp

@@ -0,0 +1,74 @@
+/**
+ * @file
+ * @author Michal Sedlak <[email protected]>
+ * @brief Standard hash table implementation
+ */
+#pragma once
+
+#include "stdAllocator.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <vector>
+#include <memory>
+#include <unordered_map>
+
+namespace fdsdump {
+namespace aggregator {
+
+/**
+ * @brief A standard hash table implementation based on std::unordered_map
+ *
+ */
+class StdHashTable {
+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
+     */
+    StdHashTable(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:
+    using Map = std::unordered_map<uint8_t *, uint8_t *,
+        std::function<std::size_t(const uint8_t *)>,
+        std::function<bool(const uint8_t *, const uint8_t *)>>;
+
+    std::size_t m_key_size;
+    std::size_t m_value_size;
+    std::vector<uint8_t *> m_items;
+    StdAllocator m_allocator;
+    Map m_map;
+};
+
+} // aggregator
+} // fdsdump