p0-draft1 (#732)

* p0-draft1

* Adding changes

* Updating .gitignore

* Reverting back to the old changes

* Adding util hash instead of primer_hash

* Removing custom hash type

* Adding suggested changes

* Small changes

* Changes as suggested

* making constant consistent

* Redfining constants

* Fixing format

* capitalize t

---------

Co-authored-by: Connor Tsui <[email protected]>

Author: prashanthduvvada

src/include/primer/hyperloglog.h

@@ -1,29 +1,30 @@
 #pragma once
 
 #include <bitset>
-#include <functional>
 #include <memory>
 #include <mutex>  // NOLINT
 #include <string>
+#include <utility>
 #include <vector>
 
-#define MAX_BITS 64
-#define DEFAULT_CARDINALITY 0
+#include "common/util/hash_util.h"
 
-namespace bustub {
-
-/** @brief Hash value type. */
-using hash_t = uint64_t;
+/** @brief Capacity of the bitset stream. */
+#define BITSET_CAPACITY 64
 
-/** @brief Constant for HLL. */
-static const double CONSTANT = 0.79402;
+namespace bustub {
 
-template <typename T>
+template <typename KeyType>
 class HyperLogLog {
+  /** @brief Constant for HLL. */
+  static constexpr double CONSTANT = 0.79402;
+
  public:
+  /** @brief Disable default constructor. */
   HyperLogLog() = delete;
 
-  explicit HyperLogLog(int16_t n_bits) : cardinality_(0) {}
+  /** @brief Parameterized constructor. */
+  explicit HyperLogLog(int16_t n_bits);
 
   /**
    * @brief Getter value for cardinality.
@@ -37,7 +38,7 @@ class HyperLogLog {
    *
    * @param[in] val - value that's added into hyperloglog
    */
-  auto AddElem(T val) -> void;
+  auto AddElem(KeyType val) -> void;
 
   /**
    * @brief Function that computes cardinality.
@@ -51,7 +52,15 @@ class HyperLogLog {
    * @param[in] val - value
    * @returns hash integer of given input value
    */
-  inline auto CalculateHash(T val) -> hash_t;
+  inline auto CalculateHash(KeyType val) -> hash_t {
+    Value val_obj;
+    if constexpr (std::is_same<KeyType, std::string>::value) {
+      val_obj = Value(VARCHAR, val);
+    } else {
+      val_obj = Value(BIGINT, val);
+    }
+    return bustub::HashUtil::HashValue(&val_obj);
+  }
 
   /**
    * @brief Function that computes binary.
@@ -60,15 +69,15 @@ class HyperLogLog {
    * @param[in] hash
    * @returns binary of a given hash
    */
-  auto ComputeBinary(const hash_t &hash) const -> std::bitset<MAX_BITS>;
+  auto ComputeBinary(const hash_t &hash) const -> std::bitset<BITSET_CAPACITY>;
 
   /**
    * @brief Function that computes leading zeros.
    *
    * @param[in] bset - binary values of a given bitset
    * @returns leading zeros of given binary set
    */
-  auto PositionOfLeftmostOne(const std::bitset<MAX_BITS> &bset) const -> uint64_t;
+  auto PositionOfLeftmostOne(const std::bitset<BITSET_CAPACITY> &bset) const -> uint64_t;
 
   /** @brief Cardinality value. */
   size_t cardinality_;

src/include/primer/hyperloglog_presto.h

@@ -1,39 +1,46 @@
 #pragma once
 
 #include <bitset>
-#include <functional>
 #include <memory>
 #include <mutex>  // NOLINT
+#include <sstream>
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
-#define BUCKET_SIZE 4UL
-#define CONSTANT 0.79402
-#define MAX_SIZE 7UL
+#include "common/util/hash_util.h"
+
+/** @brief Dense bucket size. */
+#define DENSE_BUCKET_SIZE 4
+/** @brief Overflow bucket size. */
+#define OVERFLOW_BUCKET_SIZE 3
+
+/** @brief Total bucket size. */
+#define TOTAL_BUCKET_SIZE (DENSE_BUCKET_SIZE + OVERFLOW_BUCKET_SIZE)
 
 namespace bustub {
 
-template <typename T>
+template <typename KeyType>
 class HyperLogLogPresto {
   /**
    * INSTRUCTIONS: Testing framework will use the GetDenseBucket and GetOverflow function,
    * hence SHOULD NOT be deleted. It's essential to use the dense_bucket_
    * data structure.
    */
 
-  /** @brief Hash type. */
-  using hash_t = uint64_t;
+  /** @brief Constant for HLL. */
+  static constexpr double CONSTANT = 0.79402;
 
  public:
   /** @brief Disabling default constructor. */
   HyperLogLogPresto() = delete;
 
   /** @brief Parameterized constructor. */
-  explicit HyperLogLogPresto(int16_t n_leading_bits) : cardinality_(0) {}
+  explicit HyperLogLogPresto(int16_t n_leading_bits);
 
   /** @brief Returns the dense_bucket_ data structure. */
-  auto GetDenseBucket() const -> std::vector<std::bitset<BUCKET_SIZE>> { return dense_bucket_; }
+  auto GetDenseBucket() const -> std::vector<std::bitset<DENSE_BUCKET_SIZE>> { return dense_bucket_; }
 
   /** @brief Returns overflow bucket of a specific given index. */
   auto GetOverflowBucketofIndex(uint16_t idx) { return overflow_bucket_[idx]; }
@@ -42,7 +49,7 @@ class HyperLogLogPresto {
   auto GetCardinality() const -> uint64_t { return cardinality_; }
 
   /** @brief Element is added for HLL calculation. */
-  auto AddElem(T val) -> void;
+  auto AddElem(KeyType val) -> void;
 
   /** @brief Function to compute cardinality. */
   auto ComputeCardinality() -> void;
@@ -54,13 +61,23 @@ class HyperLogLogPresto {
    *
    * @returns hash value
    */
-  inline auto CalculateHash(T val) -> hash_t { return std::hash<T>{}(val); }
+  inline auto CalculateHash(KeyType val) -> hash_t {
+    Value val_obj;
+    if constexpr (std::is_same<KeyType, std::string>::value) {
+      val_obj = Value(VARCHAR, val);
+      return bustub::HashUtil::HashValue(&val_obj);
+    }
+    if constexpr (std::is_same<KeyType, int64_t>::value) {
+      return static_cast<hash_t>(val);
+    }
+    return 0;
+  }
 
   /** @brief Structure holding dense buckets (or also known as registers). */
-  std::vector<std::bitset<BUCKET_SIZE>> dense_bucket_;
+  std::vector<std::bitset<DENSE_BUCKET_SIZE>> dense_bucket_;
 
   /** @brief Structure holding overflow buckets. */
-  std::unordered_map<uint16_t, std::bitset<MAX_SIZE - BUCKET_SIZE>> overflow_bucket_;
+  std::unordered_map<uint16_t, std::bitset<OVERFLOW_BUCKET_SIZE>> overflow_bucket_;
 
   /** @brief Storing cardinality value */
   uint64_t cardinality_;

src/primer/hyperloglog.cpp

@@ -2,32 +2,29 @@
 
 namespace bustub {
 
-template <typename T>
-auto inline HyperLogLog<T>::CalculateHash(T val) -> hash_t {
-  /** @todo student -  implement the function */
-  return 0;
-}
+template <typename KeyType>
+HyperLogLog<KeyType>::HyperLogLog(int16_t n_bits) : cardinality_(0) {}
 
-template <typename T>
-auto HyperLogLog<T>::ComputeBinary(const hash_t &hash) const -> std::bitset<MAX_BITS> {
-  /** @todo student - implement the function */
+template <typename KeyType>
+auto HyperLogLog<KeyType>::ComputeBinary(const hash_t &hash) const -> std::bitset<BITSET_CAPACITY> {
+  /** @TODO(student) Implement this function! */
   return {0};
 }
 
-template <typename T>
-auto HyperLogLog<T>::PositionOfLeftmostOne(const std::bitset<MAX_BITS> &bset) const -> uint64_t {
-  /** @todo student - implement the function*/
+template <typename KeyType>
+auto HyperLogLog<KeyType>::PositionOfLeftmostOne(const std::bitset<BITSET_CAPACITY> &bset) const -> uint64_t {
+  /** @TODO(student) Implement this function! */
   return 0;
 }
 
-template <typename T>
-auto HyperLogLog<T>::AddElem(T val) -> void {
-  /** @todo implement the function */
+template <typename KeyType>
+auto HyperLogLog<KeyType>::AddElem(KeyType val) -> void {
+  /** @TODO(student) Implement this function! */
 }
 
-template <typename T>
-auto HyperLogLog<T>::ComputeCardinality() -> void {
-  /** @todo - student implement the function */
+template <typename KeyType>
+auto HyperLogLog<KeyType>::ComputeCardinality() -> void {
+  /** @TODO(student) Implement this function! */
 }
 
 template class HyperLogLog<int64_t>;

src/primer/hyperloglog_presto.cpp

@@ -2,14 +2,17 @@
 
 namespace bustub {
 
-template <typename T>
-auto HyperLogLogPresto<T>::AddElem(T val) -> void {
-  /** @todo (student) has to fill the function */
+template <typename KeyType>
+HyperLogLogPresto<KeyType>::HyperLogLogPresto(int16_t n_leading_bits) : cardinality_(0) {}
+
+template <typename KeyType>
+auto HyperLogLogPresto<KeyType>::AddElem(KeyType val) -> void {
+  /** @TODO(student) Implement this function! */
 }
 
 template <typename T>
 auto HyperLogLogPresto<T>::ComputeCardinality() -> void {
-  // TODO(student) - implement the function
+  /** @TODO(student) Implement this function! */
 }
 
 template class HyperLogLogPresto<int64_t>;