filterbit

Author: marcelm

src/index.cpp

@@ -244,6 +244,16 @@ void StrobemerIndex::populate(float f, unsigned n_threads) {
     partial_filter_cutoff = filter_cutoff;
     stats.elapsed_hash_index = hash_index_timer.duration();
     stats.distinct_strobemers = unique_mers;
+
+    // TODO
+    if (true) { //(filter_cutoff >= randstrobes.size()) {
+        // TODO do not work on last filter_cutoff randstrobes
+        for (size_t i = 0; i < randstrobes.size(); ++i) {
+            if (get_hash(i) == get_hash(i + filter_cutoff)) {
+                randstrobes[i].set_filtered();
+            }
+        }
+    }
 }
 
 void StrobemerIndex::assign_all_randstrobes(const std::vector<uint64_t>& randstrobe_counts, size_t n_threads) {
@@ -310,7 +320,8 @@ void StrobemerIndex::assign_randstrobes(size_t ref_index, size_t offset) {
                 randstrobe.strobe1_pos,
                 static_cast<uint32_t>(ref_index),
                 static_cast<uint8_t>(randstrobe.strobe2_pos - randstrobe.strobe1_pos),
-                randstrobe.first_strobe_is_main
+                randstrobe.first_strobe_is_main,
+                0
             };
         }
         chunk.clear();

src/index.hpp

@@ -100,7 +100,7 @@ struct StrobemerIndex {
 
         auto pos = std::lower_bound(randstrobes.begin() + position_start,
                                     randstrobes.begin() + position_end,
-                                    RefRandstrobe{key, 0, 0, 0, 0},
+                                    RefRandstrobe{key, 0, 0, 0, 0, 0},
                                     cmp);
         if ((pos->hash() & hash_mask) == masked_key) return pos - randstrobes.begin();
         return end();
@@ -128,10 +128,21 @@ struct StrobemerIndex {
 
     bool is_filtered(bucket_index_t position) const {
         return get_hash(position) == get_hash(position + filter_cutoff);
+        return randstrobes[position].is_filtered();
+        //std::cerr << "pos: " << position << " " << randstrobes[position].is_filtered() << " " << is_partial_filtered(position) << '\n';
+        if (randstrobes[position].is_filtered() != is_partial_filtered(position)) {
+            throw std::runtime_error("bla");
+        }
+        return is_partial_filtered(position); //randstrobes[position].is_filtered();
     }
 
     bool is_partial_filtered(bucket_index_t position) const {
         return get_main_hash(position) == get_main_hash(position + partial_filter_cutoff);
+        if (filter_cutoff != partial_filter_cutoff) {
+            throw std::runtime_error("not equal");
+        }
+        return randstrobes[position].is_filtered();
+        //return get_main_hash(position) == get_main_hash(position + partial_filter_cutoff);
     }
 
     unsigned int get_strobe1_position(bucket_index_t position) const {
@@ -205,7 +216,7 @@ struct StrobemerIndex {
 
         auto pos = std::upper_bound(randstrobes.begin() + position,
                                     randstrobes.begin() + position_end,
-                                    RefRandstrobe{key, 0, 0, 0, 0},
+                                    RefRandstrobe{key, 0, 0, 0, 0, 0},
                                     cmp);
         return (pos - randstrobes.begin() - 1) - position + 1;
     }

src/randstrobes.hpp

@@ -29,8 +29,8 @@ struct RefRandstrobe {
 public:
     RefRandstrobe() : m_hash_offset_flag(0), m_position(0), m_ref_index(0) { }
 
-    RefRandstrobe(randstrobe_hash_t hash, uint32_t position, uint32_t ref_index, uint8_t offset, bool first_strobe_is_main)
-        : m_hash_offset_flag((hash & RANDSTROBE_HASH_MASK) | (offset << 2) | first_strobe_is_main)
+    RefRandstrobe(randstrobe_hash_t hash, uint32_t position, uint32_t ref_index, uint8_t offset, bool first_strobe_is_main, bool is_filtered)
+        : m_hash_offset_flag((hash & RANDSTROBE_HASH_MASK) | (offset << 2) | (is_filtered << 1) | first_strobe_is_main)
         , m_position(position)
         , m_ref_index(ref_index)
     { }
@@ -65,6 +65,14 @@ struct RefRandstrobe {
         return m_position;
     }
 
+    bool is_filtered() const {
+        return (m_hash_offset_flag & 2) != 0;
+    }
+
+    void set_filtered() {
+        m_hash_offset_flag |= 2;
+    }
+
     static constexpr size_t max_number_of_references = (1ul << 32) - 1;
 };
 

tests/test_randstrobes.cpp

@@ -8,11 +8,12 @@ TEST_CASE("test RefRandstrobe constructor") {
     uint32_t ref_index = RefRandstrobe::max_number_of_references - 1;
     uint8_t offset = 255;
     bool first_strobe_is_main = true;
-    RefRandstrobe rr{hash, position, ref_index, offset, first_strobe_is_main};
+    RefRandstrobe rr{hash, position, ref_index, offset, first_strobe_is_main, true};
 
     CHECK(rr.hash() == hash);
     CHECK(rr.position() == position);
     CHECK(rr.reference_index() == ref_index);
     CHECK(rr.strobe2_offset() == offset);
     CHECK(rr.first_strobe_is_main() == first_strobe_is_main);
+    CHECK(rr.is_filtered());
 }