common/bloom_filter: make compressible_bloom_filter encodable

Signed-off-by: Sage Weil <sage@inktank.com>

diff --git a/src/common/bloom_filter.cc b/src/common/bloom_filter.cc
index f602b80149e04f6d3f45c39ce35c0e3aa64a3bf0..a14434076aa25d2c32f9b771e83e9a3b989d9f9c 100644 (file)
--- a/src/common/bloom_filter.cc
+++ b/src/common/bloom_filter.cc
@@ -74,3 +74,96 @@ void bloom_filter::generate_test_instances(list<bloom_filter*>& ls)
   ls.back()->insert("boof");
   ls.back()->insert("boogggg");
 }
+
+
+void compressible_bloom_filter::encode(bufferlist& bl) const
+{
+  ENCODE_START(1, 1, bl);
+  ::encode((uint64_t)salt_count_, bl);
+  uint32_t s = size_list.size();
+  ::encode(s, bl);
+  for (vector<size_t>::const_iterator p = size_list.begin();
+       p != size_list.end(); ++p)
+    ::encode((uint64_t)*p, bl);
+  ::encode((uint64_t)inserted_element_count_, bl);
+  ::encode((uint64_t)random_seed_, bl);
+  bufferptr bp((const char*)bit_table_, raw_table_size_);
+  ::encode(bp, bl);
+  ENCODE_FINISH(bl);
+}
+
+void compressible_bloom_filter::decode(bufferlist::iterator& p)
+{
+  DECODE_START(1, p);
+  uint64_t v;
+  ::decode(v, p);
+  salt_count_ = v;
+
+  uint32_t s;
+  ::decode(s, p);
+  size_list.resize(s);
+  for (unsigned i = 0; i < s; i++) {
+    ::decode(v, p);
+    size_list[i] = v;
+  }
+  if (size_list.size())
+    table_size_ = size_list.back();
+  else
+    table_size_ = 0;
+
+  ::decode(v, p);
+  inserted_element_count_ = v;
+  ::decode(v, p);
+  random_seed_ = v;
+  bufferlist t;
+  ::decode(t, p);
+
+  salt_.clear();
+  generate_unique_salt();
+  raw_table_size_ = t.length();
+  assert(raw_table_size_ == table_size_ / bits_per_char);
+  delete bit_table_;
+  bit_table_ = new cell_type[raw_table_size_];
+  t.copy(0, raw_table_size_, (char *)bit_table_);
+
+  DECODE_FINISH(p);
+}
+
+void compressible_bloom_filter::dump(Formatter *f) const
+{
+  f->dump_unsigned("salt_count", salt_count_);
+  f->dump_unsigned("raw_table_size", raw_table_size_);
+  f->dump_unsigned("insert_count", inserted_element_count_);
+  f->dump_unsigned("random_seed", random_seed_);
+
+  f->open_array_section("table_sizes");
+  for (vector<size_t>::const_iterator p = size_list.begin();
+       p != size_list.end(); ++p)
+    f->dump_unsigned("size", (uint64_t)*p);
+  f->close_section();
+
+  f->open_array_section("salt_table");
+  for (std::vector<bloom_type>::const_iterator i = salt_.begin(); i != salt_.end(); ++i)
+    f->dump_unsigned("salt", *i);
+  f->close_section();
+
+  f->open_array_section("bit_table");
+  for (unsigned i = 0; i < raw_table_size_; ++i)
+    f->dump_unsigned("byte", (unsigned)bit_table_[i]);
+  f->close_section();
+}
+
+void compressible_bloom_filter::generate_test_instances(list<compressible_bloom_filter*>& ls)
+{
+  ls.push_back(new compressible_bloom_filter(10, .5, 1));
+  ls.push_back(new compressible_bloom_filter(10, .5, 1));
+  ls.back()->insert("foo");
+  ls.back()->insert("bar");
+  ls.push_back(new compressible_bloom_filter(50, .5, 1));
+  ls.back()->insert("foo");
+  ls.back()->insert("bar");
+  ls.back()->insert("baz");
+  ls.back()->insert("boof");
+  ls.back()->compress(20);
+  ls.back()->insert("boogggg");
+}

diff --git a/src/common/bloom_filter.hpp b/src/common/bloom_filter.hpp
index 6216c7fb34d42e1918b22dec1bcb58cef5a58d66..1c988fadbd11274664e6137c24a5f544583039ea 100644 (file)
--- a/src/common/bloom_filter.hpp
+++ b/src/common/bloom_filter.hpp
@@ -549,6 +549,8 @@ class compressible_bloom_filter : public bloom_filter
 {
 public:
 
+  compressible_bloom_filter() : bloom_filter() {}
+
   compressible_bloom_filter(const std::size_t& predicted_element_count,
                            const double& false_positive_probability,
                            const std::size_t& random_seed)
@@ -557,6 +559,14 @@ public:
     size_list.push_back(table_size_);
   }
 
+  compressible_bloom_filter(const std::size_t& salt_count,
+                           std::size_t table_size,
+                           const std::size_t& random_seed)
+    : bloom_filter(salt_count, table_size, random_seed)
+  {
+    size_list.push_back(table_size_);
+  }
+
   inline virtual std::size_t size() const
   {
     return size_list.back();
@@ -592,6 +602,8 @@ public:
     delete[] bit_table_;
     bit_table_ = tmp;
     size_list.push_back(new_table_size);
+    table_size_ = new_table_size;
+    raw_table_size_ = table_size_ / bits_per_char;
 
     return true;
   }
@@ -609,7 +621,13 @@ private:
   }
 
   std::vector<std::size_t> size_list;
+public:
+  void encode(bufferlist& bl) const;
+  void decode(bufferlist::iterator& bl);
+  void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<compressible_bloom_filter*>& ls);
 };
+WRITE_CLASS_ENCODER(compressible_bloom_filter)
 
 #endif
 

diff --git a/src/test/encoding/types.h b/src/test/encoding/types.h
index 59e55a11b2359d4b5a76fed5a37b3ecd9dc69cc8..77c8729e986aabf8438e934d4717266f59e03135 100644 (file)
--- a/src/test/encoding/types.h
+++ b/src/test/encoding/types.h
@@ -6,6 +6,7 @@ TYPE(filepath)
 
 #include "common/bloom_filter.hpp"
 TYPE(bloom_filter)
+TYPE(compressible_bloom_filter)
 
 #include "common/snap_types.h"
 TYPE(SnapContext)