Add repro test_fp_num_tuples_out_of_bounds_bug_trunk_build_filters() and instrumentation.

Author: gapisback

src/trunk.c

@@ -724,6 +724,7 @@ struct trunk_compact_bundle_req {
    uint64                tuples_reclaimed;
    uint64                kv_bytes_reclaimed;
    fp_hdr                breq_fingerprint;
+   uint64                num_tuples;
    uint64                enq_line; // Where task was enqueued
 };
 
@@ -3610,6 +3611,7 @@ typedef struct trunk_filter_scratch {
    uint16         value[TRUNK_MAX_PIVOTS];
    routing_filter filter[TRUNK_MAX_PIVOTS];
    fp_hdr         filter_fingerprint;
+   uint64         num_tuples;
 } trunk_filter_req;
 
 static inline void
@@ -3813,6 +3815,16 @@ trunk_build_filters(trunk_handle             *spl,
       trunk_process_generation_to_fp_bounds(
          spl, compact_req, generation, &fp_start, &fp_end);
 
+      debug_assert(
+         (fp_start < fingerprint_ntuples(&filter_req->filter_fingerprint)),
+         "Requested fp_start=%u should be < "
+         "fingerprint for %lu tuples."
+         " Compact bundle req type=%d, enqueued at line=%lu",
+         fp_start,
+         fingerprint_ntuples(&filter_req->filter_fingerprint),
+         compact_req->type,
+         compact_req->enq_line);
+
       uint32 *fp_arr =
          fingerprint_nth(&filter_req->filter_fingerprint, fp_start);
 

src/util.h

@@ -401,15 +401,27 @@ fingerprint_line(fp_hdr *fp)
 }
 
 /* Return the start of the n'th piece (tuple) in the fingerprint array. */
+#define fingerprint_nth(dst, src)                                              \
+   fingerprint_do_nth((dst), (src), __FILE__, __LINE__)
+
 static inline uint32 *
-fingerprint_nth(fp_hdr *fp, uint32 nth_tuple)
+fingerprint_do_nth(fp_hdr     *fp,
+                   uint32      nth_tuple,
+                   const char *file,
+                   const int   line)
 {
    // Cannot ask for a location beyond size of fingerprint array
    debug_assert((nth_tuple < fingerprint_ntuples(fp)),
-                "nth_tuple=%u, ntuples=%lu, init-line=%u",
+                "[%s:%d] nth_tuple=%u, ntuples=%lu, init'ed at line=%u"
+                ", copy_line=%u, alias_line=%u, move_line=%u ",
+                file,
+                line,
                 nth_tuple,
                 fingerprint_ntuples(fp),
-                fingerprint_line(fp));
+                fp->init_line,
+                fp->copy_line,
+                fp->alias_line,
+                fp->move_line);
 
    return ((uint32 *)memfrag_start(&fp->mf) + nth_tuple);
 }
@@ -455,6 +467,7 @@ fingerprint_do_alias(fp_hdr *dst, const fp_hdr *src, uint32 line)
    dst->ntuples            = src->ntuples;
    dst->alias_line         = line;
 
+   // Update alias refcounts
    debug_code(dst->num_aliases++);
    debug_code(dst->srcfp = (fp_hdr *)src;);
    debug_code(dst->srcfp->num_aliases++);
@@ -480,8 +493,10 @@ fingerprint_do_unalias(fp_hdr *dst, uint32 line)
    // (init_line != last_line) => 'unalias' was done
    dst->alias_line = line;
 
+   // Update alias refcounts
    debug_code(dst->num_aliases--);
    debug_code(dst->srcfp->num_aliases--);
+   debug_code(dst->srcfp->alias_line = line);
    debug_code(dst->srcfp = ((dst->num_aliases == 0) ? NULL : dst->srcfp));
 
    return (uint32 *)memfrag_start(&dst->mf);

tests/unit/large_inserts_stress_test.c

@@ -585,6 +585,74 @@ CTEST2(large_inserts_stress, test_random_keys_random_values_threaded)
    close(random_val_fd);
 }
 
+CTEST2(large_inserts_stress,
+       test_fp_num_tuples_out_of_bounds_bug_trunk_build_filters)
+{
+   char key_data[TEST_KEY_SIZE];
+   char val_data[TEST_VALUE_SIZE];
+
+   uint64 start_key = 0;
+
+   uint64 start_time = platform_get_timestamp();
+
+   threadid thread_idx = platform_get_tid();
+
+   // Test is written to insert multiples of millions per thread.
+   ASSERT_EQUAL(0, (data->num_inserts % MILLION));
+
+   platform_default_log("%s()::%d:Thread-%-lu inserts %lu (%lu million)"
+                        ", sequential key, sequential value, "
+                        "KV-pairs starting from %lu ...\n",
+                        __func__,
+                        __LINE__,
+                        thread_idx,
+                        data->num_inserts,
+                        (data->num_inserts / MILLION),
+                        start_key);
+
+   uint64 ictr = 0;
+   uint64 jctr = 0;
+
+   bool verbose_progress = TRUE;
+   memset(val_data, 'V', sizeof(val_data));
+   uint64 val_len = sizeof(val_data);
+
+   for (ictr = 0; ictr < (data->num_inserts / MILLION); ictr++) {
+      for (jctr = 0; jctr < MILLION; jctr++) {
+
+         uint64 id = (start_key + (ictr * MILLION) + jctr);
+
+         // Generate sequential key data
+         snprintf(key_data, sizeof(key_data), "%lu", id);
+         uint64 key_len = strlen(key_data);
+
+         slice key = slice_create(key_len, key_data);
+         slice val = slice_create(val_len, val_data);
+
+         int rc = splinterdb_insert(data->kvsb, key, val);
+         ASSERT_EQUAL(0, rc);
+      }
+      if (verbose_progress) {
+         platform_default_log(
+            "%s()::%d:Thread-%lu Inserted %lu million KV-pairs ...\n",
+            __func__,
+            __LINE__,
+            thread_idx,
+            (ictr + 1));
+      }
+   }
+   uint64 elapsed_ns = platform_timestamp_elapsed(start_time);
+
+   platform_default_log("%s()::%d:Thread-%lu Inserted %lu million KV-pairs in "
+                        "%lu s, %lu rows/s\n",
+                        __func__,
+                        __LINE__,
+                        thread_idx,
+                        ictr, // outer-loop ends at #-of-Millions inserted
+                        NSEC_TO_SEC(elapsed_ns),
+                        (data->num_inserts / NSEC_TO_SEC(elapsed_ns)));
+}
+
 /*
  * ----------------------------------------------------------------------------
  * do_inserts_n_threads() - Driver function that will fire-up n-threads to