nonstatic seed + move semantics

Author: Gillgamesh

include/sketch/sketch_columns.h

@@ -16,19 +16,19 @@ class FixedSizeSketchColumn {
 private:
   Bucket *buckets;
   Bucket deterministic_bucket = {0, 0};
-  uint16_t col_idx; // determines column seeding
+  uint64_t seed;
   uint8_t capacity;
 public:
-  static uint64_t seed;
-  static void set_seed(uint64_t new_seed) {
+  void set_seed(uint64_t new_seed) {
     seed = new_seed;
   };  
-  static const uint64_t get_seed() {
+  uint64_t get_seed() const {
     return seed;
   };
 
-  FixedSizeSketchColumn(uint8_t capacity, uint16_t col_idx);
+  FixedSizeSketchColumn(uint8_t capacity, uint64_t seed);
   FixedSizeSketchColumn(const FixedSizeSketchColumn &other);
+  FixedSizeSketchColumn(FixedSizeSketchColumn &&other);
   ~FixedSizeSketchColumn();
   SketchSample<vec_t> sample() const;
   void clear();
@@ -60,10 +60,13 @@ class FixedSizeSketchColumn {
     }
     return true;
   }
+  // move assignment operator
+  FixedSizeSketchColumn& operator=(FixedSizeSketchColumn &&other);
+
   friend std::ostream& operator<<(std::ostream &os, const FixedSizeSketchColumn &sketch) {
     os << "FixedSizeSketchColumn: " << std::endl;
     os << "Capacity: " << (int)sketch.capacity << std::endl;
-    os << "Column Index: " << (int)sketch.col_idx << std::endl;
+    os << "Column Seed: " << (int)sketch.seed << std::endl;
     os << "Deterministic Bucket: " << sketch.deterministic_bucket << std::endl;
     for (size_t i = 0; i < sketch.capacity; ++i) {
       os << "Bucket[" << i << "]: " << sketch.buckets[i] << std::endl;
@@ -76,17 +79,18 @@ class FixedSizeSketchColumn {
 
 class ResizeableSketchColumn {
 private:
-  static uint64_t seed;
   Bucket *buckets;
   Bucket deterministic_bucket = {0, 0};
-  uint16_t col_idx; // determines column seeding
+  uint64_t seed;
   uint8_t capacity;
 public:
-  static void set_seed(uint64_t new_seed) { seed = new_seed; };
-  static const uint64_t get_seed() { return seed; };
+  void set_seed(uint64_t new_seed) { seed = new_seed; };
+  uint64_t get_seed() const { return seed; };
 
-  ResizeableSketchColumn(uint8_t start_capacity, uint16_t col_idx);
+  ResizeableSketchColumn(uint8_t start_capacity, uint64_t seed);
   ResizeableSketchColumn(const ResizeableSketchColumn &other);
+  ResizeableSketchColumn(ResizeableSketchColumn &&other);
+  ResizeableSketchColumn& operator=(ResizeableSketchColumn &&other);
   ~ResizeableSketchColumn();
   SketchSample<vec_t> sample() const;
   void clear();
@@ -112,7 +116,7 @@ class ResizeableSketchColumn {
   friend std::ostream& operator<<(std::ostream &os, const ResizeableSketchColumn&sketch) {
     os << "ResizeableSketchColumn: " << std::endl;
     os << "Capacity: " << (int)sketch.capacity << std::endl;
-    os << "Column Index: " << (int)sketch.col_idx << std::endl;
+    os << "Column Seed: " << (int)sketch.seed << std::endl;
     os << "Deterministic Bucket: " << sketch.deterministic_bucket << std::endl;
     for (size_t i = 0; i < sketch.capacity; ++i) {
       os << "Bucket[" << i << "]: " << sketch.buckets[i] << std::endl;
@@ -139,17 +143,18 @@ class ResizeableSketchColumn {
 
 class ResizeableAlignedSketchColumn {
 private:
-  static uint64_t seed;
   hwy::AlignedFreeUniquePtr<Bucket[]> aligned_buckets;
   Bucket deterministic_bucket = {0, 0};
-  uint16_t col_idx; // determines column seeding
+  uint64_t seed;
   uint8_t capacity;
 public:
-  static void set_seed(uint64_t new_seed) { seed = new_seed; };
-  static const uint64_t get_seed() { return seed; };
+  void set_seed(uint64_t new_seed) { seed = new_seed; };
+  const uint64_t get_seed() { return seed; };
 
-  ResizeableAlignedSketchColumn(uint8_t start_capacity, uint16_t col_idx);
+  ResizeableAlignedSketchColumn(uint8_t start_capacity, uint64_t seed);
   ResizeableAlignedSketchColumn(const ResizeableAlignedSketchColumn &other);
+  ResizeableAlignedSketchColumn(ResizeableAlignedSketchColumn &&other);
+  ResizeableAlignedSketchColumn& operator=(ResizeableAlignedSketchColumn &&other);
   ~ResizeableAlignedSketchColumn();
   SketchSample<vec_t> sample() const;
   void clear();
@@ -175,7 +180,7 @@ class ResizeableAlignedSketchColumn {
   friend std::ostream& operator<<(std::ostream &os, const ResizeableAlignedSketchColumn&sketch) {
     os << "ResizeableSketchColumn: " << std::endl;
     os << "Capacity: " << (int)sketch.capacity << std::endl;
-    os << "Column Index: " << (int)sketch.col_idx << std::endl;
+    os << "Column Seed: " << (int)sketch.seed << std::endl;
     os << "Deterministic Bucket: " << sketch.deterministic_bucket << std::endl;
     for (size_t i = 0; i < sketch.capacity; ++i) {
       os << "Bucket[" << i << "]: " << sketch.aligned_buckets[i] << std::endl;

include/sketch/sketch_concept.h

@@ -51,9 +51,13 @@ concept SketchColumnConcept = requires(T t, T other) {
   { t.reset_sample_state()} -> std::same_as<void>;
   { t == other } -> std::same_as<bool>;
   // copy constructor required
-  requires std::constructible_from<T, const T&>;
-  // constructor with capacity hint, column index for seeding
-  requires std::constructible_from<T, uint8_t, uint16_t>;
+  // requires std::constructible_from<T, const T&>;
+  requires std::copy_constructible<T>;
+  // move constructor and assignment required
+  requires std::move_constructible<T>;
+  requires std::assignable_from<T&, T>;
+  // constructor with capacity hint, and a seed
+  requires std::constructible_from<T, uint8_t, uint64_t>;
   { T::suggest_capacity(std::declval<size_t>()) } -> std::same_as<uint8_t>;
 };
 

src/sketch_columns.cpp

@@ -1,18 +1,37 @@
 #include "sketch/sketch_columns.h"
 
-FixedSizeSketchColumn::FixedSizeSketchColumn(uint8_t capacity, uint16_t col_idx) :
-    capacity(capacity), col_idx(col_idx) {
+FixedSizeSketchColumn::FixedSizeSketchColumn(uint8_t capacity, uint64_t seed) :
+    capacity(capacity), seed(seed) {
   buckets = new Bucket[capacity];
   std::memset(buckets, 0, capacity * sizeof(Bucket));
 }
 
 FixedSizeSketchColumn::FixedSizeSketchColumn(const FixedSizeSketchColumn &other) :
-    capacity(other.capacity), col_idx(other.col_idx), deterministic_bucket(other.deterministic_bucket) {
+    capacity(other.capacity), seed(other.seed), deterministic_bucket(other.deterministic_bucket) {
   buckets = new Bucket[capacity];
   std::memcpy(buckets, other.buckets, capacity * sizeof(Bucket));
 }
 
+FixedSizeSketchColumn::FixedSizeSketchColumn(FixedSizeSketchColumn &&other) :
+    capacity(other.capacity), seed(other.seed), deterministic_bucket(other.deterministic_bucket) {
+    buckets = std::move(other.buckets);
+}
+
+FixedSizeSketchColumn& FixedSizeSketchColumn::operator=(FixedSizeSketchColumn &&other) {
+  if (this != &other) {
+    delete[] buckets;
+    capacity = other.capacity;
+    seed = other.seed;
+    deterministic_bucket = other.deterministic_bucket;
+    
+    buckets = other.buckets;
+    other.buckets = nullptr;
+  }
+  return *this;
+}
+
 FixedSizeSketchColumn::~FixedSizeSketchColumn() {
+  // note nullptr is safe to delete
   delete[] buckets;
 }
 
@@ -29,8 +48,8 @@ uint8_t FixedSizeSketchColumn::get_depth() const {
 void FixedSizeSketchColumn::serialize(std::ostream &binary_out) const {
   binary_out.write((char *) buckets, capacity * sizeof(Bucket));
   binary_out.write((char *) &deterministic_bucket, sizeof(Bucket));
+  binary_out.write((char *) &seed, sizeof(uint64_t));
   binary_out.write((char *) &capacity, sizeof(uint8_t));
-  binary_out.write((char *) &col_idx, sizeof(uint8_t));
 }
 
 SketchSample<vec_t> FixedSizeSketchColumn::sample() const {
@@ -59,25 +78,45 @@ void FixedSizeSketchColumn::merge(FixedSizeSketchColumn &other) {
 
 void FixedSizeSketchColumn::update(const vec_t update) {
   vec_hash_t checksum = Bucket_Boruvka::get_index_hash(update, seed);
-  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed + col_idx, capacity-1);
+  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed, capacity-1);
   // assert(depth < capacity);
   buckets[depth] ^= {update, checksum};
   deterministic_bucket ^= {update, checksum};
 }
 
 
-ResizeableSketchColumn::ResizeableSketchColumn(uint8_t start_capacity, uint16_t col_idx) :
-    capacity(start_capacity), col_idx(col_idx) {
+ResizeableSketchColumn::ResizeableSketchColumn(uint8_t start_capacity, uint64_t seed) :
+    capacity(start_capacity), seed(seed) {
     buckets = new Bucket[start_capacity];
     std::memset(buckets, 0, capacity * sizeof(Bucket));
 }
 
 ResizeableSketchColumn::ResizeableSketchColumn(const ResizeableSketchColumn &other) :
-    capacity(other.capacity), col_idx(other.col_idx), deterministic_bucket(other.deterministic_bucket) {
+    capacity(other.capacity), seed(other.seed), deterministic_bucket(other.deterministic_bucket) {
   buckets = new Bucket[capacity];
   std::memcpy(buckets, other.buckets, capacity * sizeof(Bucket));
 }
 
+ResizeableSketchColumn::ResizeableSketchColumn(ResizeableSketchColumn &&other) :
+    capacity(other.capacity), seed(other.seed), deterministic_bucket(other.deterministic_bucket) {
+    // move constructor
+    buckets = other.buckets;
+    other.buckets = nullptr;
+}
+
+ResizeableSketchColumn& ResizeableSketchColumn::operator=(ResizeableSketchColumn &&other) {
+  if (this != &other) {
+    delete[] buckets;
+    capacity = other.capacity;
+    seed = other.seed;
+    deterministic_bucket = other.deterministic_bucket;
+    
+    buckets = other.buckets;
+    other.buckets = nullptr;
+  }
+  return *this;
+}
+
 ResizeableSketchColumn::~ResizeableSketchColumn() {
   delete[] buckets;
 }
@@ -107,8 +146,8 @@ void ResizeableSketchColumn::clear() {
 void ResizeableSketchColumn::serialize(std::ostream &binary_out) const {
   binary_out.write((char *) buckets, capacity * sizeof(Bucket));
   binary_out.write((char *) &deterministic_bucket, sizeof(Bucket));
+  binary_out.write((char *) &seed, sizeof(uint64_t));
   binary_out.write((char *) &capacity, sizeof(uint8_t));
-  binary_out.write((char *) &col_idx, sizeof(uint8_t));
 }
 
 SketchSample<vec_t> ResizeableSketchColumn::sample() const {
@@ -128,7 +167,7 @@ void ResizeableSketchColumn::update(const vec_t update) {
   // TODO - remove magic number
   // TODO - get_index_depth needs to be fixed. hashes need to be longer
   // than 32 bits if we're not using the deep bucket buffer idea.
-  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed + col_idx, 60);
+  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed, 60);
   deterministic_bucket ^= {update, checksum};
 
   if (depth >= capacity) {
@@ -160,16 +199,16 @@ uint8_t ResizeableSketchColumn::get_depth() const {
 
 
 
-ResizeableAlignedSketchColumn::ResizeableAlignedSketchColumn(uint8_t start_capacity, uint16_t col_idx) :
-    capacity(start_capacity), col_idx(col_idx) {
+ResizeableAlignedSketchColumn::ResizeableAlignedSketchColumn(uint8_t start_capacity, uint64_t seed) :
+    capacity(start_capacity), seed(seed) {
 
     // auto aligned_memptr = hwy::MakeUniqueAlignedArray<Bucket>(start_capacity);
     aligned_buckets = hwy::AllocateAligned<Bucket>(start_capacity);
     std::memset(aligned_buckets.get(), 0, capacity * sizeof(Bucket));
 }
 
 ResizeableAlignedSketchColumn::ResizeableAlignedSketchColumn(const ResizeableAlignedSketchColumn &other) :
-    capacity(other.capacity), col_idx(other.col_idx), deterministic_bucket(other.deterministic_bucket) {
+    capacity(other.capacity), seed(other.seed), deterministic_bucket(other.deterministic_bucket) {
   aligned_buckets = hwy::AllocateAligned<Bucket>(capacity);
   std::memcpy(aligned_buckets.get(), other.aligned_buckets.get(), capacity * sizeof(Bucket));
 }
@@ -200,8 +239,8 @@ void ResizeableAlignedSketchColumn::clear() {
 void ResizeableAlignedSketchColumn::serialize(std::ostream &binary_out) const {
   binary_out.write((char *) aligned_buckets.get(), capacity * sizeof(Bucket));
   binary_out.write((char *) &deterministic_bucket, sizeof(Bucket));
+  binary_out.write((char *) &seed, sizeof(uint64_t));
   binary_out.write((char *) &capacity, sizeof(uint8_t));
-  binary_out.write((char *) &col_idx, sizeof(uint8_t));
 }
 
 SketchSample<vec_t> ResizeableAlignedSketchColumn::sample() const {
@@ -221,7 +260,7 @@ void ResizeableAlignedSketchColumn::update(const vec_t update) {
   // TODO - remove magic number
   // TODO - get_index_depth needs to be fixed. hashes need to be longer
   // than 32 bits if we're not using the deep bucket buffer idea.
-  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed + col_idx, 60);
+  col_hash_t depth = Bucket_Boruvka::get_index_depth_legacy(update, seed, 60);
   deterministic_bucket ^= {update, checksum};
 
   if (depth >= capacity) {
@@ -252,11 +291,6 @@ uint8_t ResizeableAlignedSketchColumn::get_depth() const {
   return 0;
 }
 
-uint64_t ResizeableSketchColumn::seed = 0;
-uint64_t FixedSizeSketchColumn::seed = 0;
-uint64_t ResizeableAlignedSketchColumn::seed = 0;
-
-
 
 static_assert(SketchColumnConcept<FixedSizeSketchColumn, vec_t>,
               "FixedSizeSketchColumn does not satisfy SketchColumnConcept");

test/sketch_test.cpp

@@ -478,13 +478,12 @@ TEST(SketchTestSuite, TestRawBucketUpdate) {
   ASSERT_GT(successes, 0);
 }
 
-// using TestDefaultSketchColumn = FixedSizeSketchColumn;
-using TestDefaultSketchColumn = ResizeableSketchColumn;
+using TestDefaultSketchColumn = FixedSizeSketchColumn;
+// using TestDefaultSketchColumn = ResizeableSketchColumn;
 
 TEST(SketchColumnTestSuite, TestSketchColumnSampling) {
-  TestDefaultSketchColumn::set_seed(get_seed());
   // ResizeableSketchColumn::seed = get_seed();
-  TestDefaultSketchColumn column(18, 0);
+  TestDefaultSketchColumn column(18, get_seed());
   column.update(10);
   auto sample = column.sample();
   ASSERT_EQ(sample.result, GOOD);
@@ -503,10 +502,10 @@ TEST(SketchColumnTestSuite, TestSketchColumnSampling) {
 
 TEST(SketchColumnTestSuite, TestSketchColumnMerging) {
   size_t num_nodes = 1 << 12;
-  TestDefaultSketchColumn::set_seed(get_seed());
+  auto seed = get_seed();
   for (size_t col_idx =0; col_idx < 16; col_idx++) {
-    TestDefaultSketchColumn column1(TestDefaultSketchColumn::suggest_capacity(num_nodes), col_idx);
-    TestDefaultSketchColumn column2(TestDefaultSketchColumn::suggest_capacity(num_nodes), col_idx);
+    TestDefaultSketchColumn column1(TestDefaultSketchColumn::suggest_capacity(num_nodes), seed + col_idx);
+    TestDefaultSketchColumn column2(TestDefaultSketchColumn::suggest_capacity(num_nodes), seed + col_idx);
     for (vec_t i = 0; i < (1 << 11); i++) {
       column1.update(i);
       column2.update(i + 128);
@@ -526,10 +525,9 @@ TEST(SketchColumnTestSuite, TestSketchColumnMerging) {
 }
 
 TEST(SketchColumnTestSuite, TestSketchColumnMergeMany) {
-  TestDefaultSketchColumn::set_seed(get_seed());
   std::vector<TestDefaultSketchColumn> columns(
       1 << 13, TestDefaultSketchColumn(
-                   TestDefaultSketchColumn::suggest_capacity(1 << 14), 0));
+                   TestDefaultSketchColumn::suggest_capacity(1 << 14), get_seed()));
   for (size_t i = 0; i < columns.size(); i++) {
     columns[i].update(i);
   }