Skip to content
Snippets Groups Projects
Commit f930ffd8 authored by Wlad's avatar Wlad
Browse files

feat: format and add missing imports

parent cde9b4e8
No related branches found
No related tags found
No related merge requests found
Pipeline #105730 failed
Stage: test
Hide whitespace changes
Inline Side-by-side
src/bloom/bloom_filter.hpp
+ 168
− 167
View file @ f930ffd8
......@@ -12,173 +12,174 @@ namespace filters {
template <typename FilterParameter, size_t _k, typename OptimizationParameter>
struct Filter<FilterType::Bloom, FilterParameter, _k, OptimizationParameter> {
using FP = FilterParameter;
static constexpr size_t k = _k;
using OP = OptimizationParameter;
static constexpr bool supports_add = OP::simd == parameter::SIMD::Scalar or
(FP::variant == bloom::Variant::Sectorized and
FP::vectorization == bloom::Vectorization::Vertical);
static constexpr bool supports_add_partition = supports_add;
// (variant == Sectorized and blockSize == 32bit) -> registerSize == 32bit
static_assert(not(FP::variant == bloom::Variant::Sectorized and
FP::blockSize == bloom::BlockSize::_32bit) or
OP::registerSize == parameter::RegisterSize::_32bit,
"Register Blocked variants expects the corresponding Register Size!");
// (variant == Sectorized and blockSize == 64bit) -> registerSize == 64bit
static_assert(not(FP::variant == bloom::Variant::Sectorized and
FP::blockSize == bloom::BlockSize::_64bit) or
OP::registerSize == parameter::RegisterSize::_64bit,
"Register Blocked variants expects the corresponding Register Size!");
using Vector = simd::Vector<OP::registerSize, OP::simd>;
using T = typename Vector::T;
using Addresser = addresser::Addresser<OP::addressingMode, Vector>;
using Container = bloom::BloomContainer<FP::blockSize, OP::partitioning, Vector, Addresser>;
using Hasher = hash::Hasher<OP::hashingMode, Vector, 0>;
using PartitionSet = partition::PartitionSet<OP::partitioning, Vector>;
using Constructor = bloom::BloomConstructor<FP::variant,
FP::vectorization,
FP::blockSize,
FP::groups,
k,
OP::registerSize,
OP::simd,
Container,
Hasher>;
using Counter = bloom::BloomCounter<FP::variant,
FP::vectorization,
FP::blockSize,
FP::groups,
k,
OP::registerSize,
OP::simd,
Container,
Hasher>;
size_t s, n_partitions;
Container container;
Constructor constructor;
Counter counter;
task::TaskQueue<OP::multiThreading> queue;
Filter(size_t s, size_t n_partitions, size_t n_threads, size_t n_tasks_per_level)
: s(s), n_partitions(n_partitions), queue(n_threads, n_tasks_per_level) {}
forceinline void init(const T *histogram) {
static_assert(supports_add_partition, "not supported!");
n_partitions = std::max(n_partitions, 1ul);
container = std::move(Container(k, s, n_partitions, histogram));
}
forceinline bool contains(const T &value) const {
return contains(value, value & (n_partitions - 1));
}
forceinline bool contains(const T &value, size_t index) const {
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
return counter.contains(container, Vector(value), 1, 0);
} else {
return counter.contains(container, Vector(value), 1, index);
}
}
forceinline bool add_all(const T *values, size_t length) {
return add_partition(values, length, 0);
}
forceinline bool add_partition(const T *values, size_t length, size_t index) {
static_assert(supports_add, "not supported!");
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
constructor.construct_partition(container, values, length, 0);
} else {
constructor.construct_partition(container, values, length, index);
}
return true;
}
forceinline bool add(const T &value) {
return add(value, value & (n_partitions - 1));
}
forceinline bool add(const T &value, size_t index) {
static_assert(supports_add, "not supported!");
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
constructor.insert(container, Vector(value), 1, 0);
} else {
constructor.insert(container, Vector(value), 1, index);
}
return true;
}
bool construct(T *values, size_t length) {
PartitionSet partitions(n_partitions);
n_partitions = partitions.n_partitions;
if constexpr (OP::multiThreading == parameter::MultiThreading::Disabled) {
partitions.init(values, length);
container = std::move(Container(k, s, n_partitions, partitions.histogram));
constructor.construct(container, partitions);
} else {
partitions.init(values, length, queue);
queue.add_task([&](size_t) {
container = std::move(Container(k, s, n_partitions, partitions.histogram));
});
queue.add_barrier();
constructor.construct(container, partitions, queue);
queue.execute_tasks();
}
return true;
}
size_t count(T *values, size_t length) {
PartitionSet partitions(n_partitions);
if constexpr (OP::multiThreading == parameter::MultiThreading::Disabled) {
partitions.init(values, length);
return counter.count(container, partitions);
} else {
partitions.init(values, length, queue);
std::atomic<size_t> count{0};
counter.count(container, partitions, count, queue);
queue.execute_tasks();
return count;
}
}
size_t size() const {
return container.length();
}
size_t avg_size() const {
return size() / n_partitions;
}
size_t retries() const {
return 0;
}
std::string to_string() {
std::string s = "\n{\n";
s += "\t\"k\": " + std::to_string(k) + ",\n";
s += "\t\"size\": " + std::to_string(size() * 8) + " bits,\n";
s += "\t\"avg_size\": " + std::to_string(size() * 8) + " bits,\n";
s += "\t\"n_partitions\": " + std::to_string(n_partitions) + ",\n";
s += "\t\"filter_params\": " + FP::to_string() + ",\n";
s += "\t\"optimization_params\": " + OP::to_string() + "\n";
s += "}\n";
return s;
}
using FP = FilterParameter;
static constexpr size_t k = _k;
using OP = OptimizationParameter;
static constexpr bool supports_add = OP::simd == parameter::SIMD::Scalar or
(FP::variant == bloom::Variant::Sectorized and
FP::vectorization == bloom::Vectorization::Vertical);
static constexpr bool supports_add_partition = supports_add;
static constexpr bool supports_remove = false;
// (variant == Sectorized and blockSize == 32bit) -> registerSize == 32bit
static_assert(not(FP::variant == bloom::Variant::Sectorized and
FP::blockSize == bloom::BlockSize::_32bit) or
OP::registerSize == parameter::RegisterSize::_32bit,
"Register Blocked variants expects the corresponding Register Size!");
// (variant == Sectorized and blockSize == 64bit) -> registerSize == 64bit
static_assert(not(FP::variant == bloom::Variant::Sectorized and
FP::blockSize == bloom::BlockSize::_64bit) or
OP::registerSize == parameter::RegisterSize::_64bit,
"Register Blocked variants expects the corresponding Register Size!");
using Vector = simd::Vector<OP::registerSize, OP::simd>;
using T = typename Vector::T;
using Addresser = addresser::Addresser<OP::addressingMode, Vector>;
using Container = bloom::BloomContainer<FP::blockSize, OP::partitioning, Vector, Addresser>;
using Hasher = hash::Hasher<OP::hashingMode, Vector, 0>;
using PartitionSet = partition::PartitionSet<OP::partitioning, Vector>;
using Constructor = bloom::BloomConstructor<FP::variant,
FP::vectorization,
FP::blockSize,
FP::groups,
k,
OP::registerSize,
OP::simd,
Container,
Hasher>;
using Counter = bloom::BloomCounter<FP::variant,
FP::vectorization,
FP::blockSize,
FP::groups,
k,
OP::registerSize,
OP::simd,
Container,
Hasher>;
size_t s, n_partitions;
Container container;
Constructor constructor;
Counter counter;
task::TaskQueue<OP::multiThreading> queue;
Filter(size_t s, size_t n_partitions, size_t n_threads, size_t n_tasks_per_level)
: s(s), n_partitions(n_partitions), queue(n_threads, n_tasks_per_level) {}
forceinline void init(const T *histogram) {
static_assert(supports_add_partition, "not supported!");
n_partitions = std::max(n_partitions, 1ul);
container = std::move(Container(k, s, n_partitions, histogram));
}
forceinline bool contains(const T &value) const {
return contains(value, value & (n_partitions - 1));
}
forceinline bool contains(const T &value, size_t index) const {
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
return counter.contains(container, Vector(value), 1, 0);
} else {
return counter.contains(container, Vector(value), 1, index);
}
}
forceinline bool add_all(const T *values, size_t length) {
return add_partition(values, length, 0);
}
forceinline bool add_partition(const T *values, size_t length, size_t index) {
static_assert(supports_add, "not supported!");
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
constructor.construct_partition(container, values, length, 0);
} else {
constructor.construct_partition(container, values, length, index);
}
return true;
}
forceinline bool add(const T &value) {
return add(value, value & (n_partitions - 1));
}
forceinline bool add(const T &value, size_t index) {
static_assert(supports_add, "not supported!");
if constexpr (OP::partitioning == parameter::Partitioning::Disabled) {
constructor.insert(container, Vector(value), 1, 0);
} else {
constructor.insert(container, Vector(value), 1, index);
}
return true;
}
bool construct(T *values, size_t length) {
PartitionSet partitions(n_partitions);
n_partitions = partitions.n_partitions;
if constexpr (OP::multiThreading == parameter::MultiThreading::Disabled) {
partitions.init(values, length);
container = std::move(Container(k, s, n_partitions, partitions.histogram));
constructor.construct(container, partitions);
} else {
partitions.init(values, length, queue);
queue.add_task([&](size_t) {
container = std::move(Container(k, s, n_partitions, partitions.histogram));
});
queue.add_barrier();
constructor.construct(container, partitions, queue);
queue.execute_tasks();
}
return true;
}
size_t count(T *values, size_t length) {
PartitionSet partitions(n_partitions);
if constexpr (OP::multiThreading == parameter::MultiThreading::Disabled) {
partitions.init(values, length);
return counter.count(container, partitions);
} else {
partitions.init(values, length, queue);
std::atomic<size_t> count{0};
counter.count(container, partitions, count, queue);
queue.execute_tasks();
return count;
}
}
size_t size() const {
return container.length();
}
size_t avg_size() const {
return size() / n_partitions;
}
size_t retries() const {
return 0;
}
std::string to_string() {
std::string s = "\n{\n";
s += "\t\"k\": " + std::to_string(k) + ",\n";
s += "\t\"size\": " + std::to_string(size() * 8) + " bits,\n";
s += "\t\"avg_size\": " + std::to_string(size() * 8) + " bits,\n";
s += "\t\"n_partitions\": " + std::to_string(n_partitions) + ",\n";
s += "\t\"filter_params\": " + FP::to_string() + ",\n";
s += "\t\"optimization_params\": " + OP::to_string() + "\n";
s += "}\n";
return s;
}
};
} // namespace filters
\ No newline at end of file
src/bloom/bloom_parameter.hpp
+ 81
− 78
View file @ f930ffd8
#pragma once
#include <cstddef>
#include <string>
namespace filters::bloom {
enum class Variant : size_t { Naive, Blocked, Sectorized, Grouped, Masked };
enum class BlockSize : size_t {
_512bit = 512,
_256bit = 256,
_128bit = 128,
_64bit = 64,
_32bit = 32
_512bit = 512,
_256bit = 256,
_128bit = 128,
_64bit = 64,
_32bit = 32
};
enum class Groups : size_t { _1group = 1, _2groups = 2, _4groups = 4, _8groups = 8 };
......@@ -18,31 +21,31 @@ enum class Vectorization : size_t { Horizontal, Vertical };
template <Variant _variant, Vectorization _vectorization, BlockSize _blockSize, Groups _groups>
struct BloomFilterParameter {
static constexpr Variant variant = _variant;
static constexpr Vectorization vectorization = _vectorization;
static constexpr BlockSize blockSize = _blockSize;
static constexpr Groups groups = _groups;
static std::string to_string() {
std::string s_variant;
switch (variant) {
case Variant::Naive: s_variant = "Naive"; break;
case Variant::Blocked: s_variant = "Blocked"; break;
case Variant::Sectorized: s_variant = "Sectorized"; break;
case Variant::Grouped: s_variant = "Grouped"; break;
}
std::string s_vectorization =
(vectorization == Vectorization::Horizontal) ? "Horizontal" : "Vertical";
std::string s = "{";
s += "\"variant\": \"" + s_variant + "\", ";
s += "\"vectorization\": \"" + s_vectorization + "\", ";
s += "\"block_size\": \"" + std::to_string(static_cast<size_t>(blockSize)) + " bits\", ";
s += "\"groups\": " + std::to_string(static_cast<size_t>(groups)) + "}";
return s;
}
static constexpr Variant variant = _variant;
static constexpr Vectorization vectorization = _vectorization;
static constexpr BlockSize blockSize = _blockSize;
static constexpr Groups groups = _groups;
static std::string to_string() {
std::string s_variant;
switch (variant) {
case Variant::Naive: s_variant = "Naive"; break;
case Variant::Blocked: s_variant = "Blocked"; break;
case Variant::Sectorized: s_variant = "Sectorized"; break;
case Variant::Grouped: s_variant = "Grouped"; break;
}
std::string s_vectorization =
(vectorization == Vectorization::Horizontal) ? "Horizontal" : "Vertical";
std::string s = "{";
s += "\"variant\": \"" + s_variant + "\", ";
s += "\"vectorization\": \"" + s_vectorization + "\", ";
s += "\"block_size\": \"" + std::to_string(static_cast<size_t>(blockSize)) + " bits\", ";
s += "\"groups\": " + std::to_string(static_cast<size_t>(groups)) + "}";
return s;
}
};
/*
......@@ -56,88 +59,88 @@ struct BloomFilterParameter {
*/
template <size_t>
using Naive32 = BloomFilterParameter<Variant::Naive,
Vectorization::Horizontal,
BlockSize::_32bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_32bit,
Groups::_1group>;
template <size_t>
using Naive64 = BloomFilterParameter<Variant::Naive,
Vectorization::Horizontal,
BlockSize::_64bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_64bit,
Groups::_1group>;
template <size_t>
using Blocked32 = BloomFilterParameter<Variant::Sectorized,
Vectorization::Horizontal,
BlockSize::_32bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_32bit,
Groups::_1group>;
template <size_t>
using Blocked64 = BloomFilterParameter<Variant::Sectorized,
Vectorization::Horizontal,
BlockSize::_64bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_64bit,
Groups::_1group>;
template <size_t>
using Blocked128 = BloomFilterParameter<Variant::Blocked,
Vectorization::Horizontal,
BlockSize::_128bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_128bit,
Groups::_1group>;
template <size_t>
using Blocked256 = BloomFilterParameter<Variant::Blocked,
Vectorization::Horizontal,
BlockSize::_256bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_256bit,
Groups::_1group>;
template <size_t>
using Blocked512 = BloomFilterParameter<Variant::Blocked,
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_1group>;
template <size_t>
using Sectorized128 = BloomFilterParameter<Variant::Sectorized,
Vectorization::Horizontal,
BlockSize::_128bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_128bit,
Groups::_1group>;
template <size_t>
using Sectorized256 = BloomFilterParameter<Variant::Sectorized,
Vectorization::Horizontal,
BlockSize::_256bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_256bit,
Groups::_1group>;
template <size_t>
using Sectorized512 = BloomFilterParameter<Variant::Sectorized,
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_1group>;
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_1group>;
template <size_t>
using Grouped2 = BloomFilterParameter<Variant::Grouped,
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_2groups>;
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_2groups>;
template <size_t>
using Grouped4 = BloomFilterParameter<Variant::Grouped,
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_4groups>;
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_4groups>;
template <size_t>
using Grouped8 = BloomFilterParameter<Variant::Grouped,
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_8groups>;
Vectorization::Horizontal,
BlockSize::_512bit,
Groups::_8groups>;
template <size_t>
using Sectorized128Vertical = BloomFilterParameter<Variant::Sectorized,
Vectorization::Vertical,
BlockSize::_128bit,
Groups::_1group>;
Vectorization::Vertical,
BlockSize::_128bit,
Groups::_1group>;
template <size_t>
using Sectorized256Vertical = BloomFilterParameter<Variant::Sectorized,
Vectorization::Vertical,
BlockSize::_256bit,
Groups::_1group>;
Vectorization::Vertical,
BlockSize::_256bit,
Groups::_1group>;
template <size_t>
using Sectorized512Vertical = BloomFilterParameter<Variant::Sectorized,
Vectorization::Vertical,
BlockSize::_512bit,
Groups::_1group>;
Vectorization::Vertical,
BlockSize::_512bit,
Groups::_1group>;
} // namespace filters::bloom
src/bloom/container/bloom_container.hpp
+ 102
− 98
View file @ f930ffd8
#pragma once
#include <cstdint>
#include <cstddef>
#include <bloom/bloom_parameter.hpp>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <partition/partition_set.hpp>
#include <simd/helper.hpp>
namespace filters::bloom {
template<BlockSize blockSize, parameter::Partitioning partitioning, typename Vector, typename Addresser>
struct BloomContainer {
using T = typename Vector::T;
static constexpr size_t address_bits = Addresser::address_bits;
Addresser addresser;
T *filter;
size_t n_bytes;
T *offsets;
template <BlockSize blockSize,
parameter::Partitioning partitioning,
typename Vector,
typename Addresser>
struct BloomContainer {
using T = typename Vector::T;
static constexpr size_t address_bits = Addresser::address_bits;
Addresser addresser;
T *filter;
size_t n_bytes;
T *offsets;
BloomContainer() : filter(nullptr), n_bytes(0), offsets(nullptr) {}
explicit BloomContainer(BloomContainer &&other)
: addresser(std::move(other.addresser)),
filter(other.filter),
n_bytes(other.n_bytes),
offsets(other.offsets) {
other.filter = nullptr;
other.offsets = nullptr;
}
BloomContainer &operator=(BloomContainer &&other) noexcept {
if (this != &other) {
if (offsets) {
free(offsets);
}
if (filter) {
simd::vfree(filter, n_bytes, true);
}
BloomContainer() : filter(nullptr), n_bytes(0), offsets(nullptr) {
}
addresser = std::move(other.addresser);
filter = other.filter;
n_bytes = other.n_bytes;
offsets = other.offsets;
explicit BloomContainer(BloomContainer &&other) : addresser(std::move(other.addresser)), filter(other.filter),
n_bytes(other.n_bytes), offsets(other.offsets) {
other.filter = nullptr;
other.offsets = nullptr;
}
BloomContainer &operator=(BloomContainer &&other) noexcept {
if (this != &other) {
if (offsets) {
free(offsets);
}
if (filter) {
simd::vfree(filter, n_bytes, true);
}
addresser = std::move(other.addresser);
filter = other.filter;
n_bytes = other.n_bytes;
offsets = other.offsets;
other.filter = nullptr;
other.offsets = nullptr;
}
return *this;
return *this;
}
BloomContainer(size_t k, size_t s, size_t n_partitions, const T *histogram) {
T *h = new T[n_partitions];
for (size_t i = 0; i < n_partitions; i++) {
h[i] = histogram[i] * k * s / 100 / static_cast<size_t>(blockSize) + 1;
#ifdef DEBUG_FILTER
std::cout << "h[" << i << "]: " << h[i] << std::endl;
std::cout << "histogram[" << i << "]: " << histogram[i] << std::endl;
#endif
}
BloomContainer(size_t k, size_t s, size_t n_partitions, const T *histogram) {
T *h = new T[n_partitions];
for (size_t i = 0; i < n_partitions; i++) {
h[i] = histogram[i] * k * s / 100 / static_cast<size_t>(blockSize) + 1;
}
addresser = std::move(Addresser(h, n_partitions));
delete[] (h);
addresser = std::move(Addresser(h, n_partitions));
delete[](h);
T last_offset = 0;
T last_offset = 0;
if constexpr (partitioning == parameter::Partitioning::Enabled) {
offsets = simd::valloc<Vector>(simd::valign<Vector>(n_partitions * sizeof(T)), 0);
for (size_t i = 0; i < n_partitions; i++) {
size_t n_blocks = addresser.get_size(i);
if constexpr (partitioning == parameter::Partitioning::Enabled) {
offsets = simd::valloc<Vector>(simd::valign<Vector>(n_partitions * sizeof(T)), 0);
for (size_t i = 0; i < n_partitions; i++) {
size_t n_blocks = addresser.get_size(i);
offsets[i] = last_offset;
last_offset += n_blocks;
}
} else {
offsets = nullptr;
last_offset = addresser.get_size(0);
offsets[i] = last_offset;
last_offset += n_blocks;
}
n_bytes = simd::valign<Vector>(last_offset * static_cast<size_t>(blockSize) / 8);
filter = simd::valloc<Vector>(n_bytes, 0, true);
} else {
offsets = nullptr;
last_offset = addresser.get_size(0);
}
~BloomContainer() {
if (offsets) {
free(offsets);
}
if (filter) {
simd::vfree(filter, n_bytes, true);
}
}
n_bytes = simd::valign<Vector>(last_offset * static_cast<size_t>(blockSize) / 8);
filter = simd::valloc<Vector>(n_bytes, 0, true);
}
forceinline
Vector compute_offset_vertical(const size_t index, const Vector &address) const {
if constexpr (partitioning == parameter::Partitioning::Enabled) {
const Vector offset = Vector(offsets[index]);
return offset + addresser.compute_address_vertical(index, address);
} else {
return addresser.compute_address_vertical(index, address);
}
~BloomContainer() {
if (offsets) {
free(offsets);
}
forceinline
Vector compute_offset_horizontal(const size_t index, const Vector &address) const {
if constexpr (partitioning == parameter::Partitioning::Enabled) {
const Vector offset = Vector::load(offsets + index);
return offset + addresser.compute_address_horizontal(index, address);
} else {
return addresser.compute_address_horizontal(index, address);
}
if (filter) {
simd::vfree(filter, n_bytes, true);
}
forceinline
size_t size(size_t index) const {
return addresser.get_size(index);
}
forceinline Vector compute_offset_vertical(const size_t index, const Vector &address) const {
if constexpr (partitioning == parameter::Partitioning::Enabled) {
const Vector offset = Vector(offsets[index]);
return offset + addresser.compute_address_vertical(index, address);
} else {
return addresser.compute_address_vertical(index, address);
}
forceinline
size_t length() const {
return n_bytes;
}
forceinline Vector compute_offset_horizontal(const size_t index, const Vector &address) const {
if constexpr (partitioning == parameter::Partitioning::Enabled) {
const Vector offset = Vector::load(offsets + index);
return offset + addresser.compute_address_horizontal(index, address);
} else {
return addresser.compute_address_horizontal(index, address);
}
}
forceinline
T *data() const {
return filter;
}
};
} // filters::bloom
forceinline size_t size(size_t index) const {
return addresser.get_size(index);
}
forceinline size_t length() const {
return n_bytes;
}
forceinline T *data() const {
return filter;
}
};
} // namespace filters::bloom
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment