wip: not-yet-working c reproducer for issue #201

Author: rosenhouse

tests/unit/bug_repro_201_test.c

@@ -0,0 +1,240 @@
+// Copyright 2021 VMware, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// WIP attempt to reproduce https://github.com/vmware/splinterdb/issues/201
+// but not yet working
+
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <pthread.h>
+
+#include "splinterdb/platform_public.h"
+#include "splinterdb/kvstore_basic.h"
+#include "unit_tests.h"
+#include "../functional/random.h"
+#include "ctest.h"
+
+#define KEY_SIZE   47
+#define VALUE_SIZE 8
+
+CTEST_DATA(bug_repro_201)
+{
+   kvstore_basic *   kvsb;
+   kvstore_basic_cfg cfg;
+};
+
+CTEST_SETUP(bug_repro_201)
+{
+   data->cfg = (kvstore_basic_cfg){
+      .filename = "/fdb-data/nvme0n1/testing/c_repro.db",
+      // .filename       = TEST_DB_NAME,
+      .cache_size     = 3 * Giga,
+      .disk_size      = 128 * Giga,
+      .max_key_size   = KEY_SIZE,
+      .max_value_size = VALUE_SIZE,
+   };
+
+   int rc = kvstore_basic_create(&data->cfg, &data->kvsb);
+   ASSERT_EQUAL(0, rc);
+}
+
+CTEST_TEARDOWN(bug_repro_201)
+{
+   kvstore_basic_close(data->kvsb);
+}
+
+static void
+rand_fill_buffer(random_state *rand_state, char *to_fill, size_t len_to_fill)
+{
+   random_bytes(rand_state, to_fill, len_to_fill);
+}
+
+
+static void
+do_random_lookups(const kvstore_basic *kvsb,
+                  uint32               count,
+                  random_state *       rand_state,
+                  char *               key_buffer,
+                  size_t               key_buffer_len)
+{
+
+   char   val_buffer[VALUE_SIZE];
+   _Bool  val_truncated;
+   _Bool  val_found;
+   size_t val_size;
+
+   for (uint32 i = 0; i < count; i++) {
+      rand_fill_buffer(rand_state, key_buffer, key_buffer_len);
+      int rc = kvstore_basic_lookup(kvsb,
+                                    key_buffer,
+                                    key_buffer_len,
+                                    val_buffer,
+                                    VALUE_SIZE,
+                                    &val_size,
+                                    &val_truncated,
+                                    &val_found);
+      ASSERT_EQUAL(0, rc);
+   }
+}
+
+static uint32
+do_range_delete(const kvstore_basic *kvsb,
+                char *               start_key,
+                size_t               start_key_len,
+                uint32               count)
+{
+
+   // naive range delete
+
+   // 1. collect all the keys we need to delete
+   char *keys_to_delete = calloc(count, KEY_SIZE);
+
+   kvstore_basic_iterator *it;
+   int rc = kvstore_basic_iter_init(kvsb, &it, start_key, start_key_len);
+   ASSERT_EQUAL(0, rc);
+
+   const char *key;
+   const char *val;
+   size_t      key_len, val_len;
+   uint32      num_found = 0;
+   for (; kvstore_basic_iter_valid(it); kvstore_basic_iter_next(it)) {
+      kvstore_basic_iter_get_current(it, &key, &key_len, &val, &val_len);
+      ASSERT_EQUAL(KEY_SIZE, key_len);
+      memcpy(keys_to_delete + num_found * KEY_SIZE, key, KEY_SIZE);
+      num_found++;
+      if (num_found >= count) {
+         break;
+      }
+   }
+   rc = kvstore_basic_iter_status(it);
+   ASSERT_EQUAL(0, rc);
+   kvstore_basic_iter_deinit(&it);
+
+   // 2. delete every key we collected
+   for (uint32 i = 0; i < num_found; i++) {
+      char *key_to_delete = keys_to_delete + i * KEY_SIZE;
+      kvstore_basic_delete(kvsb, key_to_delete, KEY_SIZE);
+   }
+
+   free(keys_to_delete);
+
+   return num_found;
+}
+
+
+static void
+do_random_inserts(const kvstore_basic *kvsb,
+                  uint32               count,
+                  random_state *       rand_state,
+                  char *               key_buffer,
+                  size_t               key_buffer_len,
+                  char *               val_buffer,
+                  size_t               val_buffer_len)
+{
+
+   for (uint32 i = 0; i < count; i++) {
+      rand_fill_buffer(rand_state, key_buffer, key_buffer_len);
+      rand_fill_buffer(rand_state, val_buffer, val_buffer_len);
+      int rc = kvstore_basic_insert(
+         kvsb, key_buffer, key_buffer_len, val_buffer, val_buffer_len);
+      ASSERT_EQUAL(0, rc);
+   }
+}
+
+typedef struct {
+   kvstore_basic *kvsb;
+   uint32_t       ops_per_round;
+   uint64_t       seed;
+} worker_config;
+
+static uint32_t
+rand_in_range(random_state *rs, uint32_t min, uint32_t max)
+{
+   return random_next_uint32(rs) % (max + 1 - min) + min;
+}
+
+static void *
+thread_worker(void *w)
+{
+   char key_buf[KEY_SIZE]     = {0};
+   char value_buf[VALUE_SIZE] = {0};
+
+   worker_config *cfg = (worker_config *)w;
+
+   kvstore_basic_register_thread(cfg->kvsb);
+
+   random_state rand_state;
+   random_init(&rand_state, cfg->seed, 0);
+
+   for (uint32_t round = 0; round < 1000; round++) {
+      uint32_t min_to_write = 3 * cfg->ops_per_round / 4;
+      uint32_t max_to_write = cfg->ops_per_round;
+      uint32_t num_inserts =
+         rand_in_range(&rand_state, min_to_write, max_to_write);
+      do_random_inserts(cfg->kvsb,
+                        num_inserts,
+                        &rand_state,
+                        key_buf,
+                        KEY_SIZE,
+                        value_buf,
+                        VALUE_SIZE);
+
+
+      do_random_lookups(
+         cfg->kvsb, cfg->ops_per_round / 10, &rand_state, key_buf, KEY_SIZE);
+
+      if (round >= 100) {
+         uint32_t num_to_delete = cfg->ops_per_round - num_inserts;
+
+         char start_key[4];
+         rand_fill_buffer(&rand_state, start_key, sizeof(start_key));
+         do_range_delete(
+            cfg->kvsb, start_key, sizeof(start_key), num_to_delete);
+      }
+      fprintf(stderr, ".");
+   }
+
+   kvstore_basic_deregister_thread(cfg->kvsb);
+   return 0;
+}
+
+
+CTEST2(bug_repro_201, bug_repro_201)
+{
+   Platform_stdout_fh = stdout;
+   Platform_stderr_fh = stderr;
+   // Platform_stdout_fh = fopen("/tmp/unit_test.stdout", "a+");
+   // Platform_stderr_fh = fopen("/tmp/unit_test.stderr", "a+");
+
+
+   worker_config cfg = {
+      .kvsb          = data->kvsb,
+      .ops_per_round = 50000,
+      .seed          = 42,
+   };
+
+   const uint8_t num_threads = 4;
+   pthread_t     thread_ids[num_threads];
+
+   for (int i = 0; i < num_threads; i++) {
+      int rc = pthread_create(&thread_ids[i], NULL, &thread_worker, &cfg);
+      ASSERT_EQUAL(0, rc);
+   }
+
+   for (int i = 0; i < num_threads; i++) {
+      void *thread_rc;
+      int   rc = pthread_join(thread_ids[i], &thread_rc);
+      ASSERT_EQUAL(0, rc);
+      if (thread_rc != 0) {
+         fprintf(stderr,
+                 "Thread %d [ID=%lu] had error: %p\n",
+                 i,
+                 thread_ids[i],
+                 thread_rc);
+         ASSERT_TRUE(FALSE);
+      }
+   }
+}