feat: add reference prefix filter

src/filter.hpp

@@ -18,6 +18,7 @@
 #include <reference/efficient_cuckoofilter/efficient_cuckoofilter_filter.hpp>
 #include <reference/fastfilter/fastfilter_filter.hpp>
 #include <reference/impala/impala_bloom_filter.hpp>
+#include <reference/prefix/prefix_filter.hpp>
 #include <reference/ribbon/ribbon_filter.hpp>
 #include <reference/vacuumfilter/vacuumfilter_filter.hpp>
 

src/filter_base.hpp

@@ -20,13 +20,15 @@ enum class FilterType : size_t {
     VacuumFilter,
     LookupBloom,
     Ribbon,
-    Chained
+    Chained,
+    Prefix
 };
 
 template <FilterType filter, typename FilterParameter, size_t k, typename OptimizationParameter>
 struct Filter {
     static constexpr bool supports_add = false;
     static constexpr bool supports_add_partition = false;
+    static constexpr bool supports_remove = false;
 
     using Vector = simd::Vector<OptimizationParameter::registerSize, OptimizationParameter::simd>;
     using T = typename Vector::T;

src/reference/prefix/prefix_filter.hpp

+#pragma once
+
+#include <address/addresser.hpp>
+#include <filter_base.hpp>
+#include <hash/hasher.hpp>
+#include <prefixfilter/Tests/wrappers.hpp>
+#include <simd/vector.hpp>
+
+#include "prefix_filter_parameter.hpp"
+
+namespace filters {
+
+template <typename FilterParameter, size_t _k, typename OptimizationParameter>
+struct Filter<FilterType::Prefix, FilterParameter, _k, OptimizationParameter> {
+    static constexpr bool supports_add = true;
+    static constexpr bool supports_add_partition = false;
+    static constexpr bool supports_remove = false;
+
+    using OP = OptimizationParameter;
+    using FP = FilterParameter;
+
+    using Scalar = simd::Vector<OP::registerSize, parameter::SIMD::Scalar>;
+    using T = typename Scalar::T;
+    using spare = TC_shortcut;
+    using prefixFilter = Prefix_Filter<spare>;
+
+    unique_ptr<prefixFilter> filter;
+
+    Filter(size_t s, size_t, size_t n_threads, size_t n_tasks_per_level) {}
+
+    ~Filter() {}
+
+    forceinline void init(const T *histogram) {
+        size_t item_count = histogram[0];
+        constexpr float loads[2] = {.95, .95};
+        filter = unique_ptr<prefixFilter>(new prefixFilter(item_count, loads));
+    }
+
+    forceinline bool contains(const T &value, const size_t = 0) {
+        return filter->Find(value);
+    }
+
+    forceinline bool add(const T &value, const size_t = 0) {
+        filter->Add(value);
+        return true;
+    }
+
+    bool construct(T *values, size_t length) {
+        bool success = true;
+        for (size_t i = 0; i < length; i++) {
+            success &= add(values[i]);
+        }
+
+        return success;
+    }
+
+    size_t count(T *values, size_t length) {
+        if constexpr (OP::multiThreading == parameter::MultiThreading::Disabled) {
+        } else {
+        }
+    }
+
+    size_t size() {
+        return filter->get_byte_size();
+    }
+
+    size_t avg_size() {
+        // no partitioning available
+        return size();
+    }
+
+    size_t retries() {
+        // cannot get the number of retries needed for building from the implementation
+        return 0;
+    }
+
+    std::string to_string() {
+        std::string s = "\n{\n";
+        s += "\t\"k\": " + std::to_string(8) + ",\n";
+        s += "\t\"size\": " + std::to_string(size() * 8) + " bits,\n";
+        s += "\t\"filter_params\": " + prefix::Standard<8>::to_string() + ",\n";
+        s += "\t\"optimization_params\": " + OP::to_string() + "\n";
+        s += "}\n";
+
+        return s;
+    }
+};
+
+}  // namespace filters

src/reference/prefix/prefix_filter_parameter.hpp

+#pragma once
+#include <string>
+
+namespace filters::prefix {
+
+struct PrefixFilterParameter {
+    static std::string to_string() {
+        return {};
+    }
+};
+
+template <size_t>
+using Standard = PrefixFilterParameter;
+
+}  // namespace filters::prefix