merge test case

Author: Gillgamesh

include/recovery.h

@@ -33,11 +33,12 @@ class SparseRecovery {
         // TODO - see if we want to continue maintaining the deterministic bucket
         Bucket deterministic_bucket;
     public:
-        Sketch cleanup_sketch;
-        SparseRecovery(size_t universe_size, size_t max_recovery_size, double cleanup_sketch_support_factor, uint64_t seed):
+        Sketch *cleanup_sketch;
+        SparseRecovery(size_t universe_size, size_t max_recovery_size, double cleanup_sketch_support_factor, uint64_t seed)
             // TODO - ugly constructor
-        cleanup_sketch(universe_size, seed, ceil(cleanup_sketch_support_factor * log2(universe_size)) * 2, 1)
+        // cleanup_sketch(universe_size, seed, ceil(cleanup_sketch_support_factor * log2(universe_size)) * 2, 1)
          {
+             cleanup_sketch = new Sketch(universe_size, seed, ceil(cleanup_sketch_support_factor * log2(universe_size)) * 2, 1);
             // TODO - define the seed better
             _checksum_seed = seed;
             seed = seed * seed + 13;
@@ -94,26 +95,27 @@ class SparseRecovery {
                 Bucket &bucket = get_cfr_bucket(cfr_idx, bucket_idx);
                 bucket ^= {update, checksum};
             }
-            cleanup_sketch.update(update);
+            cleanup_sketch->update(update);
         }
         void reset() {
             // zero contents of the CFRs
             deterministic_bucket = {0, 0};
             for (size_t i=0; i < recovery_buckets.size(); i++) {
                 recovery_buckets[i] = {0, 0};
             }
-            cleanup_sketch.zero_contents();
+            cleanup_sketch->zero_contents();
         };
 
 
         // THIS IS A NON_DESTRUCTIVE OPERATION
         RecoveryResult recover() {
+            // TODO - DYNAMIc allocation grossness
             std::vector<Bucket> recovered_indices;
             std::vector<vec_t> recovered_return_vals;
             Bucket working_det_bucket = {0, 0};
             for (size_t cfr_idx=0; cfr_idx < num_levels(); cfr_idx++) {
                 auto cfr_size = get_cfr_size(cfr_idx);
-                std::cout << "level " << cfr_idx << " size " << cfr_size << std::endl;
+                // std::cout << "level " << cfr_idx << " size " << cfr_size << std::endl;
                 // temporarily zero out already recovvered things:
                 size_t previously_recovered = recovered_indices.size();
                 for (size_t i=0; i < previously_recovered; i++) {
@@ -145,8 +147,8 @@ class SparseRecovery {
                 this->update(idx);
             }
             size_t i=0;
-            for (; i < cleanup_sketch.get_num_samples(); i++) {
-                ExhaustiveSketchSample sample = cleanup_sketch.exhaustive_sample();
+            for (; i < cleanup_sketch->get_num_samples(); i++) {
+                ExhaustiveSketchSample sample = cleanup_sketch->exhaustive_sample();
                 if (sample.result == ZERO) {
                     for (auto idx: recovered_return_vals) {
                         this->update(idx);
@@ -169,7 +171,7 @@ class SparseRecovery {
             for (size_t i=0; i < recovery_buckets.size(); i++) {
                 recovery_buckets[i] ^= other.recovery_buckets[i];
             }
-            cleanup_sketch.merge(other.cleanup_sketch);
+            cleanup_sketch->merge(*other.cleanup_sketch);
         };
         ~SparseRecovery() {
 

test/recovery_test.cpp

@@ -66,7 +66,7 @@ TEST(RecoveryTestSuite, RecoveryFailureCondition) {
     // inserted.clear();
     // remove all but the final few elements
     // TODO - figure out the right place to put sketch clearing
-    recovery.cleanup_sketch.reset_sample_state();
+    recovery.cleanup_sketch->reset_sample_state();
     for (vec_t i = 0; i < (1 << 14) - 1027; i++) {
         recovery.update(i);
         inserted.erase(i);
@@ -76,4 +76,66 @@ TEST(RecoveryTestSuite, RecoveryFailureCondition) {
     std::unordered_set<vec_t> recovered3(result3.recovered_indices.begin(), result3.recovered_indices.end());
     ASSERT_EQ(result3.result, SUCCESS);
     ASSERT_EQ(recovered3, inserted);
+}
+
+TEST(RecoveryTestSuite, RecoveryForceSketchUse) {
+  // TODO - IRON THIS OUT
+    SparseRecovery recovery(1 << 20, 1 << 4, 1, get_seed());
+    std::unordered_set<vec_t> inserted;
+    for (vec_t i = 0; i < (1 << 4) * 2; i++) {
+        recovery.update(i);
+        inserted.insert(i);
+    }
+    auto result = recovery.recover();
+    ASSERT_EQ(result.result, SUCCESS);
+}
+
+TEST(RecoveryTestSuite, RecoveryMerge) {
+  // TODO - IRON THIS OUT
+    auto seed = get_seed();
+    SparseRecovery recovery1(1 << 20, 1 << 10, 1, seed);
+    SparseRecovery recovery2(1 << 20, 1 << 10, 1, seed);
+    for (vec_t i = 0; i < (1 << 10) * 2; i++) {
+        recovery1.update(i);
+    }
+    vec_t offset = 512;
+    for (vec_t i = 0; i < (1 << 10) * 2; i++) {
+        recovery1.update(i+512);
+    }
+    recovery1.merge(recovery2);
+    auto result = recovery1.recover();
+    ASSERT_EQ(result.result, SUCCESS);
+    ASSERT_EQ(result.recovered_indices.size(), 1 << 10);
+    for (auto idx: result.recovered_indices) {
+        ASSERT_TRUE(idx < 512 || idx >= 1024);
+    }
+}
+
+TEST(RecoveryTestSuite, RecoveryManyFailureProbability) {
+  // TODO - IRON THIS OUT
+    auto vector_size = 1 << 20;
+    auto recovery_size = 1 << 10;
+    auto num_sketches = 1 << 15;
+    double recovery_size_adjustment = 1;
+    auto seed = get_seed();
+    std::vector<SparseRecovery> recoveries;
+    for (vec_t i = 0; i < num_sketches; i++) {
+      recoveries.push_back(SparseRecovery(
+          vector_size, ceill(recovery_size * recovery_size_adjustment), 1,
+          seed));
+    }
+    for (size_t i = 0; i < num_sketches; i++) {
+        for (vec_t j = recovery_size * i; j < recovery_size * (i+1); j++) {
+            recoveries[i].update(j);
+        }
+    }
+    for (size_t i = 0; i < num_sketches; i++) {
+        auto result = recoveries[i].recover();
+        ASSERT_EQ(result.result, SUCCESS);
+        ASSERT_EQ(result.recovered_indices.size(), recovery_size);
+        for (auto idx: result.recovered_indices) {
+            ASSERT_TRUE(idx >= recovery_size * i && idx < recovery_size * (i+1));
+        }
+    }
+    
 }