Record format generalization

Currently, tombstone counting is bugged. But the rest of it appears to
be working.

1 files changed, 63 insertions, 44 deletions

diff --git a/tests/mutable_buffer_tests.cpp b/tests/mutable_buffer_tests.cpp
index 2112036..75cbeec 100644
--- a/tests/mutable_buffer_tests.cpp
+++ b/tests/mutable_buffer_tests.cpp
@@ -20,12 +20,14 @@
 
 #include <check.h>
 
+#define DE_MT_TEST 0
+
 using namespace de;
 
 START_TEST(t_create)
 {
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(100, true, 50, rng);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50, rng);
 
     ck_assert_ptr_nonnull(buffer);
     ck_assert_int_eq(buffer->get_capacity(), 100);
@@ -44,30 +46,32 @@ END_TEST
 START_TEST(t_insert)
 {
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(100, true, 50, rng);
+    auto buffer = new MutableBuffer<WRec>(100, true, 50, rng);
 
     uint64_t key = 0;
     uint32_t val = 5;
 
+    WRec rec = {0, 5, 1};
+
     for (size_t i=0; i<99; i++) {
-        ck_assert_int_eq(buffer->append(key, val, 1, false), 1);
-        ck_assert_int_eq(buffer->check_tombstone(key, val), 0);
+        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->check_tombstone(rec), 0);
 
-        key++;
-        val++;
+        rec.key++;
+        rec.value++;
 
         ck_assert_int_eq(buffer->get_record_count(), i+1);
         ck_assert_int_eq(buffer->get_tombstone_count(), 0);
         ck_assert_int_eq(buffer->is_full(), 0);
     }
 
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 1);
+    ck_assert_int_eq(buffer->append(rec), 1);
 
-    key++;
-    val++;
+    rec.key++;
+    rec.value++;
 
     ck_assert_int_eq(buffer->is_full(), 1);
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 0);
+    ck_assert_int_eq(buffer->append(rec), 0);
 
     delete buffer;
     gsl_rng_free(rng);
@@ -79,12 +83,12 @@ END_TEST
 START_TEST(t_insert_tombstones)
 {
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(100, true, 50, rng);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50, rng);
 
-    uint64_t key = 0;
-    uint32_t val = 5;
     size_t ts_cnt = 0;
 
+    Rec rec = {0, 5};
+
     for (size_t i=0; i<99; i++) {
         bool ts = false;
         if (i % 2 == 0) {
@@ -92,11 +96,13 @@ START_TEST(t_insert_tombstones)
             ts=true;
         }
 
-        ck_assert_int_eq(buffer->append(key, val, 1.0, ts), 1);
-        ck_assert_int_eq(buffer->check_tombstone(key, val), ts);
+        rec.set_tombstone(ts);
 
-        key++;
-        val++;
+        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->check_tombstone(rec), ts);
+
+        rec.key++;
+        rec.value++;
 
         ck_assert_int_eq(buffer->get_record_count(), i+1);
         ck_assert_int_eq(buffer->get_tombstone_count(), ts_cnt);
@@ -104,16 +110,18 @@ START_TEST(t_insert_tombstones)
     }
 
     // inserting one more tombstone should not be possible
-    ck_assert_int_eq(buffer->append(key, val, 1.0, true), 0);
+    rec.set_tombstone();
+    ck_assert_int_eq(buffer->append(rec), 0);
 
 
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 1);
+    rec.set_tombstone(false);
+    ck_assert_int_eq(buffer->append(rec), 1);
 
-    key++;
-    val++;
+    rec.key++;
+    rec.value++;
 
     ck_assert_int_eq(buffer->is_full(), 1);
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 0);
+    ck_assert_int_eq(buffer->append(rec), 0);
 
     delete buffer;
     gsl_rng_free(rng);
@@ -124,11 +132,10 @@ END_TEST
 START_TEST(t_truncate)
 {
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(100, true, 100, rng);
+    auto buffer = new MutableBuffer<Rec>(100, true, 100, rng);
 
-    uint64_t key = 0;
-    uint32_t val = 5;
     size_t ts_cnt = 0;
+    Rec rec = {0, 5};
 
     for (size_t i=0; i<100; i++) {
         bool ts = false;
@@ -137,25 +144,28 @@ START_TEST(t_truncate)
             ts=true;
         }
 
-        ck_assert_int_eq(buffer->append(key, val, 1.0, ts), 1);
-        ck_assert_int_eq(buffer->check_tombstone(key, val), ts);
+        rec.set_tombstone(ts);
 
-        key++;
-        val++;
+        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->check_tombstone(rec), ts);
+
+        rec.key++;
+        rec.value++;
 
         ck_assert_int_eq(buffer->get_record_count(), i+1);
         ck_assert_int_eq(buffer->get_tombstone_count(), ts_cnt);
     }
 
     ck_assert_int_eq(buffer->is_full(), 1);
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 0);
+    rec.set_tombstone(false);
+    ck_assert_int_eq(buffer->append(rec), 0);
 
     ck_assert_int_eq(buffer->truncate(), 1);
 
     ck_assert_int_eq(buffer->is_full(), 0);
     ck_assert_int_eq(buffer->get_record_count(), 0);
     ck_assert_int_eq(buffer->get_tombstone_count(), 0);
-    ck_assert_int_eq(buffer->append(key, val, 1.0, false), 1);
+    ck_assert_int_eq(buffer->append(rec), 1);
 
     delete buffer;
     gsl_rng_free(rng);
@@ -169,7 +179,7 @@ START_TEST(t_sorted_output)
     size_t cnt = 100;
 
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(cnt, true, cnt/2, rng);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2, rng);
 
 
     std::vector<uint64_t> keys(cnt);
@@ -184,14 +194,19 @@ START_TEST(t_sorted_output)
 
     uint32_t val = 12345;
     for (size_t i=0; i<cnt-2; i++) {
-        buffer->append(keys[i], val, 1.0, false);
+        buffer->append(Rec {keys[i], val});
     }
 
-    buffer->append(keys[cnt-2], val, 1.0, true);
-    buffer->append(keys[cnt-1], val, 1.0, true);
+    Rec r1 = {keys[cnt-2], val};
+    r1.set_tombstone();
+    buffer->append(r1);
+
+    Rec r2 = {keys[cnt-1], val};
+    r2.set_tombstone();
+    buffer->append(r2);
 
 
-    WeightedRec *sorted_records = buffer->sorted_output();
+    auto *sorted_records = buffer->sorted_output();
     std::sort(keys.begin(), keys.end());
 
     for (size_t i=0; i<cnt; i++) {
@@ -204,23 +219,24 @@ START_TEST(t_sorted_output)
 END_TEST
 
 
-void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, WeightedMBuffer *buffer)
+void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, MutableBuffer<Rec> *buffer)
 {
     for (size_t i=start; i<stop; i++) {
-        buffer->append((*values)[i].first, (*values)[i].second, 1.0);
+        buffer->append({(*values)[i].first, (*values)[i].second});
     }
 
 }
 
+#if DE_MT_TEST
 START_TEST(t_multithreaded_insert)
 {
     size_t cnt = 10000;
     auto rng = gsl_rng_alloc(gsl_rng_mt19937);
-    auto buffer = new WeightedMBuffer(cnt, true, cnt/2, rng);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2, rng);
 
-    std::vector<std::pair<uint64_t, uint32_t>> records(cnt);
+    std::vector<Rec> records(cnt);
     for (size_t i=0; i<cnt; i++) {
-        records[i] = {rand(), rand()};
+        records[i] = Rec {(uint64_t) rand(), (uint32_t) rand()};
     }
 
     // perform a t_multithreaded insertion
@@ -245,15 +261,16 @@ START_TEST(t_multithreaded_insert)
     ck_assert_int_eq(buffer->get_record_count(), cnt);
 
     std::sort(records.begin(), records.end());
-    WeightedRec *sorted_records = buffer->sorted_output();
+    auto *sorted_records = buffer->sorted_output();
     for (size_t i=0; i<cnt; i++) {
-        ck_assert_int_eq(sorted_records[i].key, records[i].first);
+        ck_assert_int_eq(sorted_records[i].key, records[i].key);
     }
 
     delete buffer;
     gsl_rng_free(rng);
 }
 END_TEST
+#endif
 
 
 Suite *unit_testing()
@@ -268,7 +285,9 @@ Suite *unit_testing()
     TCase *append = tcase_create("de::MutableBuffer::append Testing");
     tcase_add_test(append, t_insert);
     tcase_add_test(append, t_insert_tombstones);
-    tcase_add_test(append, t_multithreaded_insert);
+    #if DE_MT_TEST
+        tcase_add_test(append, t_multithreaded_insert);
+    #endif
 
     suite_add_tcase(unit, append);