Hash table proxy

Author: pmenon

src/codegen/proxy/hash_table_proxy.cpp

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// hash_table_proxy.cpp
+//
+// Identification: src/codegen/proxy/hash_table_proxy.cpp
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#include "codegen/proxy/hash_table_proxy.h"
+
+#include "codegen/proxy/executor_context_proxy.h"
+
+namespace peloton {
+namespace codegen {
+
+// We need to manually define the type because it is recursive
+llvm::Type *EntryProxy::GetType(CodeGen &codegen) {
+  static const std::string kHashEntryTypeName = "peloton::Entry";
+
+  // Check if the hash entry is already defined in the module
+  auto *llvm_type = codegen.LookupType(kHashEntryTypeName);
+  if (llvm_type != nullptr) {
+    return llvm_type;
+  }
+
+  // Define the thing (the first field is the 64bit hash, the second is the
+  // next HashEntry* pointer)
+  auto *entry_type =
+      llvm::StructType::create(codegen.GetContext(), kHashEntryTypeName);
+  std::vector<llvm::Type *> elements = {
+      codegen.Int64Type(),        // The hash value
+      entry_type->getPointerTo()  // The next HashEntry* pointer
+  };
+  entry_type->setBody(elements, /*is_packed*/ false);
+  return entry_type;
+}
+
+DEFINE_TYPE(HashTable, "peloton::HashTable", memory, directory, size, mask,
+            entry_buffer, num_elems, capacity, stats);
+
+DEFINE_METHOD(peloton::codegen::util, HashTable, Init);
+DEFINE_METHOD(peloton::codegen::util, HashTable, Insert);
+DEFINE_METHOD(peloton::codegen::util, HashTable, InsertLazy);
+DEFINE_METHOD(peloton::codegen::util, HashTable, BuildLazy);
+DEFINE_METHOD(peloton::codegen::util, HashTable, ReserveLazy);
+DEFINE_METHOD(peloton::codegen::util, HashTable, MergeLazyUnfinished);
+DEFINE_METHOD(peloton::codegen::util, HashTable, Destroy);
+
+}  // namespace codegen
+}  // namespace peloton

src/codegen/util/hash_table.cpp

@@ -21,6 +21,7 @@ namespace util {
 
 static const uint32_t kDefaultNumElements = 256;
 static const uint32_t kNumBlockElems = 1024;
+static const uint32_t kDefaultEstimatePrecision = 5;
 
 static_assert((kDefaultNumElements & (kDefaultNumElements - 1)) == 0,
               "Default number of elements must be a power of two");
@@ -32,7 +33,7 @@ static_assert((kDefaultNumElements & (kDefaultNumElements - 1)) == 0,
 ////////////////////////////////////////////////////////////////////////////////
 
 HashTable::EntryBuffer::EntryBuffer(::peloton::type::AbstractPool &memory,
-                                    uint64_t entry_size)
+                                    uint32_t entry_size)
     : memory_(memory), entry_size_(entry_size) {
   // We also need to allocate some space to store tuples. Tuples are stored
   // externally from the main hash table in a separate values memory space.
@@ -87,15 +88,16 @@ HashTable::Entry *HashTable::EntryBuffer::NextFree() {
  *
  */
 
-HashTable::HashTable(::peloton::type::AbstractPool &memory, uint64_t key_size,
-                     uint64_t value_size)
+HashTable::HashTable(::peloton::type::AbstractPool &memory, uint32_t key_size,
+                     uint32_t value_size)
     : memory_(memory),
       directory_(nullptr),
       directory_size_(0),
       directory_mask_(0),
       entry_buffer_(memory, Entry::Size(key_size, value_size)),
       num_elems_(0),
-      capacity_(kDefaultNumElements) {
+      capacity_(kDefaultNumElements),
+      unique_key_estimate_(libcount::HLL::Create(kDefaultEstimatePrecision)) {
   // Upon creation, we allocate room for kDefaultNumElements in the hash table.
   // We assume 50% load factor on the directory, thus the directory size is
   // twice the number of elements.
@@ -115,13 +117,13 @@ HashTable::~HashTable() {
 }
 
 void HashTable::Init(HashTable &table, executor::ExecutorContext &exec_ctx,
-                     uint64_t key_size, uint64_t value_size) {
+                     uint32_t key_size, uint32_t value_size) {
   new (&table) HashTable(*exec_ctx.GetPool(), key_size, value_size);
 }
 
 void HashTable::Destroy(HashTable &table) { table.~HashTable(); }
 
-char *HashTable::StoreTupleLazy(uint64_t hash) {
+char *HashTable::InsertLazy(uint64_t hash) {
   // Since this is a lazy insertion, we just need to acquire/allocate an entry
   // from storage. It is assumed that actual construction of the hash table is
   // done by a subsequent call to BuildLazy() only after ALL lazy insertions
@@ -145,7 +147,7 @@ char *HashTable::StoreTupleLazy(uint64_t hash) {
   return entry->data;
 }
 
-char *HashTable::StoreTuple(uint64_t hash) {
+char *HashTable::Insert(uint64_t hash) {
   // Resize the hash table if needed
   if (NeedsResize()) {
     Resize();
@@ -223,9 +225,13 @@ void HashTable::ReserveLazy(
 }
 
 void HashTable::MergeLazyUnfinished(const HashTable &other) {
+  // Begin with the head of the linked list of entries, stored in the first
+  // directory entry
+  PELOTON_ASSERT(other.directory_[0] != nullptr);
   auto *head = other.directory_[0];
+
   while (head != nullptr) {
-    // Find the index and stash the next entry in the linked list
+    // Compute the index and stash the next entry in the linked list
     uint64_t index = head->hash & directory_mask_;
     Entry *next = head->next;
 

src/include/codegen/proxy/hash_table_proxy.h

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// hash_table_proxy.h
+//
+// Identification: src/include/codegen/proxy/hash_table_proxy.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "codegen/proxy/proxy.h"
+#include "codegen/util/hash_table.h"
+
+namespace peloton {
+namespace codegen {
+
+/// The proxy for HashTable::Entry
+PROXY(Entry) {
+  DECLARE_MEMBER(0, uint64_t, hash_val);
+  DECLARE_MEMBER(1, util::HashTable::Entry *, next);
+  DECLARE_TYPE;
+};
+
+/// The proxy for CCHashTable
+PROXY(HashTable) {
+  DECLARE_MEMBER(0, char *, memory);
+  DECLARE_MEMBER(1, util::HashTable::Entry **, directory);
+  DECLARE_MEMBER(2, uint64_t, size);
+  DECLARE_MEMBER(3, uint64_t, mask);
+  DECLARE_MEMBER(4, char[sizeof(util::HashTable::EntryBuffer)], entry_buffer);
+  DECLARE_MEMBER(5, uint64_t, num_elems);
+  DECLARE_MEMBER(6, uint64_t, capacity);
+  DECLARE_MEMBER(7, char[sizeof(std::unique_ptr<char>)], stats);
+  DECLARE_TYPE;
+
+  // Proxy all methods that will be called from codegen
+  DECLARE_METHOD(Init);
+  DECLARE_METHOD(Insert);
+  DECLARE_METHOD(InsertLazy);
+  DECLARE_METHOD(BuildLazy);
+  DECLARE_METHOD(ReserveLazy);
+  DECLARE_METHOD(MergeLazyUnfinished);
+  DECLARE_METHOD(Destroy);
+};
+
+/// The type builders for Entry and HashTable
+TYPE_BUILDER(Entry, util::HashTable::Entry);
+TYPE_BUILDER(HashTable, util::HashTable);
+
+}  // namespace codegen
+}  // namespace peloton

src/include/codegen/util/hash_table.h

@@ -14,6 +14,8 @@
 
 #include <cstdint>
 
+#include "libcount/hll.h"
+
 #include "executor/executor_context.h"
 
 namespace peloton {
@@ -28,8 +30,8 @@ namespace util {
 class HashTable {
  public:
   /// Constructor
-  HashTable(::peloton::type::AbstractPool &memory, uint64_t key_size,
-            uint64_t value_size);
+  HashTable(::peloton::type::AbstractPool &memory, uint32_t key_size,
+            uint32_t value_size);
 
   /// Destructor
   ~HashTable();
@@ -42,7 +44,7 @@ class HashTable {
    * @param value_size The size of the values in bytes
    */
   static void Init(HashTable &table, executor::ExecutorContext &exec_ctx,
-                   uint64_t key_size, uint64_t value_size);
+                   uint32_t key_size, uint32_t value_size);
 
   /**
    * Clean up all resources allocated by the provided table
@@ -58,15 +60,15 @@ class HashTable {
    * @param hash The hash value of the tuple that will be inserted
    * @return A memory region where the key and value can be stored
    */
-  char *StoreTupleLazy(uint64_t hash);
+  char *InsertLazy(uint64_t hash);
 
   /**
    * Make room in the hash-table to store the new key-value pair.
    *
    * @param hash
    * @return
    */
-  char *StoreTuple(uint64_t hash);
+  char *Insert(uint64_t hash);
 
   /**
    *
@@ -83,7 +85,7 @@ class HashTable {
 
   /**
    *
-   * @param other
+   * @param
    */
   void MergeLazyUnfinished(const HashTable &other);
 
@@ -110,7 +112,7 @@ class HashTable {
    * @param value The value to store in the value
    */
   template <typename Key, typename Value>
-  void Insert(uint64_t hash, const Key &key, const Value &value);
+  void TypedInsertLazy(uint64_t hash, const Key &key, const Value &value);
 
   /**
    * Probe a key in the hash table. This function is used mostly for testing.
@@ -122,7 +124,7 @@ class HashTable {
    * @return True if a value was found. False otherwise.
    */
   template <typename Key, typename Value>
-  bool Probe(uint64_t hash, const Key &key, Value &value);
+  bool TypedProbe(uint64_t hash, const Key &key, Value &value);
 
   //////////////////////////////////////////////////////////////////////////////
   ///
@@ -138,7 +140,7 @@ class HashTable {
     Entry *next;
     char data[0];
 
-    static uint64_t Size(uint32_t key_size, uint32_t value_size) {
+    static uint32_t Size(uint32_t key_size, uint32_t value_size) {
       return sizeof(Entry) + key_size + value_size;
     }
   };
@@ -148,7 +150,7 @@ class HashTable {
    */
   class EntryBuffer {
    public:
-    EntryBuffer(::peloton::type::AbstractPool &memory, uint64_t entry_size);
+    EntryBuffer(::peloton::type::AbstractPool &memory, uint32_t entry_size);
 
     ~EntryBuffer();
 
@@ -163,7 +165,7 @@ class HashTable {
     // The memory pool where block allocations are sourced
     ::peloton::type::AbstractPool &memory_;
     // The sizes of each entry
-    uint64_t entry_size_;
+    uint32_t entry_size_;
     // The current active block
     MemoryBlock *block_;
     // A pointer into the block where the next position is
@@ -198,6 +200,9 @@ class HashTable {
 
   // Info about partitions
   // ...
+
+  // Stats
+  std::unique_ptr<libcount::HLL> unique_key_estimate_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -207,14 +212,15 @@ class HashTable {
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename Key, typename Value>
-void HashTable::Insert(uint64_t hash, const Key &key, const Value &value) {
-  auto *data = StoreTupleLazy(hash);
+void HashTable::TypedInsertLazy(uint64_t hash, const Key &key,
+                                const Value &value) {
+  auto *data = InsertLazy(hash);
   *reinterpret_cast<Key *>(data) = key;
   *reinterpret_cast<Value *>(data + sizeof(Key)) = value;
 }
 
 template <typename Key, typename Value>
-bool HashTable::Probe(uint64_t hash, const Key &key, Value &value) {
+bool HashTable::TypedProbe(uint64_t hash, const Key &key, Value &value) {
   // Initial index in the directory
   uint64_t index = hash & directory_mask_;