move atomicbitvector to utils

Author: Tydik42

CMakeLists.txt

@@ -266,14 +266,6 @@ CPMAddPackage(
 )
 include_directories(SYSTEM "${magic_enum_SOURCE_DIR}/include")
 
-CPMAddPackage(
-    NAME atomicbitvector
-    GITHUB_REPOSITORY ekg/atomicbitvector
-    GIT_TAG e295358fea9532fa4c37197630d037a4a53ddede
-    DOWNLOAD_ONLY True
-)
-include_directories(SYSTEM "${atomicbitvector_SOURCE_DIR}/include")
-
 if(DESBORDANTE_BUILD_TESTS)
     CPMAddPackage(
         NAME googletest

src/core/algorithms/ind/faida/inclusion_testing/sampled_inverted_index.cpp

@@ -12,7 +12,7 @@ void SampledInvertedIndex::Init(std::vector<size_t> const& sampled_hashes, int m
     max_id_ = max_id;
 
     seen_cc_indices_ = boost::dynamic_bitset<>(max_id);
-    non_covered_cc_indices_ = atomicbitvector::atomic_bv_t(max_id);
+    non_covered_cc_indices_ = util::AtomicBitVector(max_id);
 
     discovered_inds_.clear();
 }

src/core/algorithms/ind/faida/inclusion_testing/sampled_inverted_index.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <atomic_bitvector.hpp>
 #include <hash_set2.hpp>
 #include <hash_table8.hpp>
 #include <mutex>
@@ -10,6 +9,7 @@
 
 #include "core/algorithms/ind/faida/inclusion_testing/hll_data.h"
 #include "core/algorithms/ind/faida/util/simple_ind.h"
+#include "core/util/atomic_bit_vector.h"
 
 namespace algos::faida {
 
@@ -24,7 +24,7 @@ class SampledInvertedIndex {
     emhash2::HashSet<SimpleIND> discovered_inds_;
 
     boost::dynamic_bitset<> seen_cc_indices_;
-    atomicbitvector::atomic_bv_t non_covered_cc_indices_;
+    util::AtomicBitVector non_covered_cc_indices_;
 
     int max_id_;
 
@@ -37,8 +37,8 @@ class SampledInvertedIndex {
         auto set_iter = inverted_index_.find(hash);
 
         if (set_iter == inverted_index_.end()) {
-            if (!non_covered_cc_indices_.test(combination.GetIndex())) {
-                non_covered_cc_indices_.set(combination.GetIndex());
+            if (!non_covered_cc_indices_.Test(combination.GetIndex())) {
+                non_covered_cc_indices_.Set(combination.GetIndex());
             }
             return false;
         }
@@ -50,7 +50,7 @@ class SampledInvertedIndex {
     }
 
     bool IsCovered(std::shared_ptr<SimpleCC> const& combination) {
-        return !non_covered_cc_indices_.test(combination->GetIndex());
+        return !non_covered_cc_indices_.Test(combination->GetIndex());
     }
 
     bool IsIncludedIn(std::shared_ptr<SimpleCC> const& a, std::shared_ptr<SimpleCC> const& b) {

src/core/util/atomic_bit_vector.h

@@ -0,0 +1,84 @@
+/*
+ * Based on atomic_bitvector by Erik Garrison (Apache 2.0)
+ * https://github.com/ekg/atomicbitvector
+ *
+ * Simplified version without iterator support.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <limits>
+#include <memory>
+
+namespace util {
+
+class AtomicBitVector {
+public:
+    AtomicBitVector(size_t size)
+        : size_(size),
+          num_blocks_((size + kBitsPerBlock - 1) / kBitsPerBlock),
+          data_(std::make_unique<std::atomic<BlockType>[]>(num_blocks_)) {}
+
+    // Set bit to true. Returns previous value.
+    bool Set(size_t idx, std::memory_order order = std::memory_order_seq_cst) {
+        assert(idx < size_);
+        BlockType mask = kOne << BitOffset(idx);
+        return data_[BlockIndex(idx)].fetch_or(mask, order) & mask;
+    }
+
+    // Set bit to false. Returns previous value.
+    bool Reset(size_t idx, std::memory_order order = std::memory_order_seq_cst) {
+        assert(idx < size_);
+        BlockType mask = kOne << BitOffset(idx);
+        return data_[BlockIndex(idx)].fetch_and(~mask, order) & mask;
+    }
+
+    // Set bit to given value. Returns previous value.
+    bool Set(size_t idx, bool value, std::memory_order order = std::memory_order_seq_cst) {
+        return value ? Set(idx, order) : Reset(idx, order);
+    }
+
+    // Read bit value.
+    bool Test(size_t idx, std::memory_order order = std::memory_order_seq_cst) const {
+        assert(idx < size_);
+        BlockType mask = kOne << BitOffset(idx);
+        return data_[BlockIndex(idx)].load(order) & mask;
+    }
+
+    bool operator[](size_t idx) const {
+        return Test(idx);
+    }
+
+    constexpr size_t Size() const noexcept {
+        return size_;
+    }
+
+private:
+#if (ATOMIC_LLONG_LOCK_FREE == 2)
+    using BlockType = unsigned long long;
+#elif (ATOMIC_LONG_LOCK_FREE == 2)
+    using BlockType = unsigned long;
+#else
+    using BlockType = unsigned int;
+#endif
+
+    static constexpr size_t kBitsPerBlock = std::numeric_limits<BlockType>::digits;
+    static constexpr BlockType kOne = 1;
+
+    static constexpr size_t BlockIndex(size_t bit) {
+        return bit / kBitsPerBlock;
+    }
+
+    static constexpr size_t BitOffset(size_t bit) {
+        return bit % kBitsPerBlock;
+    }
+
+    size_t size_;
+    size_t num_blocks_;
+    std::unique_ptr<std::atomic<BlockType>[]> data_;
+};
+
+}  // namespace util