Update README.md

Benchmarks haven't been updated since adding metrics

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.18)
 project(
   conflict-set
-  VERSION 0.0.9
+  VERSION 0.0.10
   DESCRIPTION
     "A data structure for optimistic concurrency control on ranges of bitwise-lexicographically-ordered keys."
   HOMEPAGE_URL "https://git.weaselab.dev/weaselab/conflict-set"
@@ -19,12 +19,6 @@ include(CheckCXXSourceCompiles)
 
 set(DEFAULT_BUILD_TYPE "Release")
 
-if(EMSCRIPTEN OR CMAKE_SYSTEM_NAME STREQUAL WASI)
-  set(WASM ON)
-else()
-  set(WASM OFF)
-endif()
-
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(
     STATUS
@@ -81,15 +75,6 @@ if(EMSCRIPTEN)
 endif()
 
 if(NOT USE_SIMD_FALLBACK)
-  cmake_push_check_state()
-  list(APPEND CMAKE_REQUIRED_FLAGS -msimd128)
-  check_include_file_cxx("wasm_simd128.h" HAS_WASM_SIMD)
-  if(HAS_WASM_SIMD)
-    add_compile_options(-msimd128)
-    add_compile_definitions(HAS_WASM_SIMD)
-  endif()
-  cmake_pop_check_state()
-
   cmake_push_check_state()
   list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
   check_include_file_cxx("immintrin.h" HAS_AVX)
@@ -162,47 +147,40 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
 
   file(GLOB CORPUS_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/corpus/*)
 
-  # extra testing that relies on shared libraries, which aren't available with
+  # Shared library version of FoundationDB's skip list implementation
-  # wasm
+  add_library(skip_list SHARED SkipList.cpp)
-  if(NOT WASM)
+  target_compile_options(skip_list PRIVATE -fno-exceptions -fvisibility=hidden)
-    # Shared library version of FoundationDB's skip list implementation
+  target_include_directories(skip_list
-    add_library(skip_list SHARED SkipList.cpp)
+                             PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
-    target_compile_options(skip_list PRIVATE -fno-exceptions
+  set_target_properties(
-                                             -fvisibility=hidden)
+    skip_list PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-    target_include_directories(skip_list
+                         "${CMAKE_CURRENT_BINARY_DIR}/skip_list")
-                               PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+  set_target_properties(skip_list PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-    set_target_properties(
+  set_target_properties(skip_list PROPERTIES VERSION ${PROJECT_VERSION}
-      skip_list PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                             SOVERSION ${PROJECT_VERSION_MAJOR})
-                           "${CMAKE_CURRENT_BINARY_DIR}/skip_list")
-    set_target_properties(skip_list PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-    set_target_properties(
-      skip_list PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
-                                                      ${PROJECT_VERSION_MAJOR})
 
-    # Shared library version of a std::unordered_map-based conflict set (point
+  # Shared library version of a std::unordered_map-based conflict set (point
-    # queries only)
+  # queries only)
-    add_library(hash_table SHARED HashTable.cpp)
+  add_library(hash_table SHARED HashTable.cpp)
-    target_compile_options(hash_table PRIVATE -fno-exceptions
+  target_compile_options(hash_table PRIVATE -fno-exceptions -fvisibility=hidden)
-                                              -fvisibility=hidden)
+  target_include_directories(hash_table
-    target_include_directories(hash_table
+                             PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
-                               PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+  set_target_properties(
-    set_target_properties(
+    hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-      hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                          "${CMAKE_CURRENT_BINARY_DIR}/hash_table")
-                            "${CMAKE_CURRENT_BINARY_DIR}/hash_table")
+  set_target_properties(hash_table PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-    set_target_properties(hash_table PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
+  set_target_properties(
-    set_target_properties(
+    hash_table PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
-      hash_table PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
+                                                     ${PROJECT_VERSION_MAJOR})
-                                                       ${PROJECT_VERSION_MAJOR})
 
-    add_executable(driver_skip_list TestDriver.cpp)
+  add_executable(driver_skip_list TestDriver.cpp)
-    target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
+  target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
-    target_link_libraries(driver_skip_list PRIVATE skip_list)
+  target_link_libraries(driver_skip_list PRIVATE skip_list)
 
-    foreach(TEST ${CORPUS_TESTS})
+  foreach(TEST ${CORPUS_TESTS})
-      get_filename_component(hash ${TEST} NAME)
+    get_filename_component(hash ${TEST} NAME)
-      add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
+    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-    endforeach()
+  endforeach()
-  endif()
 
   # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)
@@ -320,7 +298,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   add_test(NAME conflict_set_cxx_api_test COMMAND conflict_set_cxx_api_test)
 
   # symbol visibility tests
-  if(NOT WASM AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+  if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
     if(APPLE)
       set(symbol_exports ${CMAKE_CURRENT_SOURCE_DIR}/apple-symbol-exports.txt)
       set(symbol_imports ${CMAKE_CURRENT_SOURCE_DIR}/apple-symbol-imports.txt)

Internal.h

@@ -580,11 +580,14 @@ namespace {
 
 template <class ConflictSetImpl, bool kEnableAssertions = true>
 struct TestDriver {
-  Arbitrary arbitrary;
+  Arbitrary *arbitrary;
-  explicit TestDriver(const uint8_t *data, size_t size)
+  explicit TestDriver(Arbitrary &a) : arbitrary(&a) {
-      : arbitrary({data, size}) {}
+#if DEBUG_VERBOSE && !defined(NDEBUG)
+    fprintf(stderr, "%p Initial version: {%" PRId64 "}\n", this, writeVersion);
+#endif
+  }
 
-  int64_t oldestVersion = arbitrary.next();
+  int64_t oldestVersion = arbitrary->next();
   int64_t writeVersion = oldestVersion;
   ConflictSetImpl cs{oldestVersion};
   ReferenceImpl refImpl{oldestVersion};
@@ -593,33 +596,34 @@ struct TestDriver {
 
   bool ok = true;
 
-  const int prefixLen = arbitrary.bounded(512);
+  const int prefixLen = arbitrary->bounded(512);
-  const int prefixByte = arbitrary.randT<uint8_t>();
+  const int prefixByte = arbitrary->randT<uint8_t>();
 
   // Call until it returns true, for "done". Check internal invariants etc
   // between calls to next.
   bool next() {
     assert(cs.getBytes() >= 0);
-    if (!arbitrary.hasEntropy()) {
+    if (!arbitrary->hasEntropy()) {
       return true;
     }
     Arena arena;
     {
-      int numPointWrites = arbitrary.bounded(100);
+      int numPointWrites = arbitrary->bounded(100);
-      int numRangeWrites = arbitrary.bounded(100);
+      int numRangeWrites = arbitrary->bounded(100);
-      int64_t v = (writeVersion += arbitrary.bounded(10) ? arbitrary.bounded(10)
+      int64_t v =
-                                                         : arbitrary.next());
+          (writeVersion +=
+           arbitrary->bounded(10) ? arbitrary->bounded(10) : arbitrary->next());
       auto *writes =
           new (arena) ConflictSet::WriteRange[numPointWrites + numRangeWrites];
       auto keys = set<std::string_view>(arena);
       while (int(keys.size()) < numPointWrites + numRangeWrites * 2) {
-        if (!arbitrary.hasEntropy()) {
+        if (!arbitrary->hasEntropy()) {
           return true;
         }
-        int keyLen = prefixLen + arbitrary.bounded(kMaxKeySuffixLen);
+        int keyLen = prefixLen + arbitrary->bounded(kMaxKeySuffixLen);
         auto *begin = new (arena) uint8_t[keyLen];
         memset(begin, prefixByte, prefixLen);
-        arbitrary.randomBytes(begin + prefixLen, keyLen - prefixLen);
+        arbitrary->randomBytes(begin + prefixLen, keyLen - prefixLen);
         keys.insert(std::string_view((const char *)begin, keyLen));
       }
 
@@ -629,7 +633,7 @@ struct TestDriver {
                rangesRemaining = numRangeWrites;
            pointsRemaining > 0 || rangesRemaining > 0; ++i) {
         bool pointRead = pointsRemaining > 0 && rangesRemaining > 0
-                             ? bool(arbitrary.bounded(2))
+                             ? bool(arbitrary->bounded(2))
                              : pointsRemaining > 0;
         if (pointRead) {
           assert(pointsRemaining > 0);
@@ -648,33 +652,20 @@ struct TestDriver {
           ++iter;
           --rangesRemaining;
         }
-#if DEBUG_VERBOSE && !defined(NDEBUG)
-        if (writes[i].end.len == 0) {
-          fprintf(stderr, "Write: {%s}\n", printable(writes[i].begin).c_str());
-        } else {
-          fprintf(stderr, "Write: [%s, %s)\n",
-                  printable(writes[i].begin).c_str(),
-                  printable(writes[i].end).c_str());
-        }
-#endif
       }
       assert(iter == keys.end());
       assert(i == numPointWrites + numRangeWrites);
 
-#if DEBUG_VERBOSE && !defined(NDEBUG)
-      fprintf(stderr, "Write @ %" PRId64 "\n", v);
-#endif
-
       // Test non-canonical writes
       if (numPointWrites > 0) {
-        int overlaps = arbitrary.bounded(numPointWrites);
+        int overlaps = arbitrary->bounded(numPointWrites);
         for (int i = 0; i < numPointWrites + numRangeWrites && overlaps > 0;
              ++i) {
           if (writes[i].end.len == 0) {
-            int keyLen = prefixLen + arbitrary.bounded(kMaxKeySuffixLen);
+            int keyLen = prefixLen + arbitrary->bounded(kMaxKeySuffixLen);
             auto *begin = new (arena) uint8_t[keyLen];
             memset(begin, prefixByte, prefixLen);
-            arbitrary.randomBytes(begin + prefixLen, keyLen - prefixLen);
+            arbitrary->randomBytes(begin + prefixLen, keyLen - prefixLen);
             writes[i].end.len = keyLen;
             writes[i].end.p = begin;
             auto c =
@@ -692,10 +683,10 @@ struct TestDriver {
           }
         }
       }
-      if (arbitrary.bounded(2)) {
+      if (arbitrary->bounded(2)) {
         // Shuffle writes
         for (int i = numPointWrites + numRangeWrites - 1; i > 0; --i) {
-          int j = arbitrary.bounded(i + 1);
+          int j = arbitrary->bounded(i + 1);
           if (i != j) {
             using std::swap;
             swap(writes[i], writes[j]);
@@ -704,7 +695,7 @@ struct TestDriver {
       }
 
       oldestVersion +=
-          arbitrary.bounded(10) ? arbitrary.bounded(10) : arbitrary.next();
+          arbitrary->bounded(10) ? arbitrary->bounded(10) : arbitrary->next();
       oldestVersion = std::min(oldestVersion, writeVersion);
 
 #ifdef THREAD_TEST
@@ -721,6 +712,20 @@ struct TestDriver {
       ready.wait();
 #endif
 
+#if DEBUG_VERBOSE && !defined(NDEBUG)
+      for (int i = 0; i < numPointWrites + numRangeWrites; ++i) {
+        if (writes[i].end.len == 0) {
+          fprintf(stderr, "%p Write: {%s}\n", this,
+                  printable(writes[i].begin).c_str());
+        } else {
+          fprintf(stderr, "%p Write: [%s, %s)\n", this,
+                  printable(writes[i].begin).c_str(),
+                  printable(writes[i].end).c_str());
+        }
+      }
+      fprintf(stderr, "%p Write @ %" PRId64 "\n", this, v);
+#endif
+
       CALLGRIND_START_INSTRUMENTATION;
       cs.addWrites(writes, numPointWrites + numRangeWrites, v);
       CALLGRIND_STOP_INSTRUMENTATION;
@@ -729,6 +734,10 @@ struct TestDriver {
         refImpl.addWrites(writes, numPointWrites + numRangeWrites, v);
       }
 
+#if DEBUG_VERBOSE && !defined(NDEBUG)
+      fprintf(stderr, "%p Set oldest version: %" PRId64 "\n", this,
+              oldestVersion);
+#endif
       cs.setOldestVersion(oldestVersion);
       if constexpr (kEnableAssertions) {
         refImpl.setOldestVersion(oldestVersion);
@@ -739,24 +748,24 @@ struct TestDriver {
 #endif
     }
     {
-      int numPointReads = arbitrary.bounded(100);
+      int numPointReads = arbitrary->bounded(100);
-      int numRangeReads = arbitrary.bounded(100);
+      int numRangeReads = arbitrary->bounded(100);
 
-      int64_t v = std::max<int64_t>(writeVersion - (arbitrary.bounded(10)
+      int64_t v = std::max<int64_t>(writeVersion - (arbitrary->bounded(10)
-                                                        ? arbitrary.bounded(10)
+                                                        ? arbitrary->bounded(10)
-                                                        : arbitrary.next()),
+                                                        : arbitrary->next()),
                                     0);
       auto *reads =
           new (arena) ConflictSet::ReadRange[numPointReads + numRangeReads];
       auto keys = set<std::string_view>(arena);
       while (int(keys.size()) < numPointReads + numRangeReads * 2) {
-        if (!arbitrary.hasEntropy()) {
+        if (!arbitrary->hasEntropy()) {
           return true;
         }
-        int keyLen = prefixLen + arbitrary.bounded(kMaxKeySuffixLen);
+        int keyLen = prefixLen + arbitrary->bounded(kMaxKeySuffixLen);
         auto *begin = new (arena) uint8_t[keyLen];
         memset(begin, prefixByte, prefixLen);
-        arbitrary.randomBytes(begin + prefixLen, keyLen - prefixLen);
+        arbitrary->randomBytes(begin + prefixLen, keyLen - prefixLen);
         keys.insert(std::string_view((const char *)begin, keyLen));
       }
 
@@ -765,7 +774,7 @@ struct TestDriver {
       for (int pointsRemaining = numPointReads, rangesRemaining = numRangeReads;
            pointsRemaining > 0 || rangesRemaining > 0; ++i) {
         bool pointRead = pointsRemaining > 0 && rangesRemaining > 0
-                             ? bool(arbitrary.bounded(2))
+                             ? bool(arbitrary->bounded(2))
                              : pointsRemaining > 0;
         if (pointRead) {
           assert(pointsRemaining > 0);
@@ -787,10 +796,10 @@ struct TestDriver {
         reads[i].readVersion = v;
 #if DEBUG_VERBOSE && !defined(NDEBUG)
         if (reads[i].end.len == 0) {
-          fprintf(stderr, "Read: {%s} @ %" PRId64 "\n",
+          fprintf(stderr, "%p Read: {%s} @ %" PRId64 "\n", this,
                   printable(reads[i].begin).c_str(), reads[i].readVersion);
         } else {
-          fprintf(stderr, "Read: [%s, %s) @ %" PRId64 "\n",
+          fprintf(stderr, "%p Read: [%s, %s) @ %" PRId64 "\n", this,
                   printable(reads[i].begin).c_str(),
                   printable(reads[i].end).c_str(), reads[i].readVersion);
         }
@@ -839,24 +848,27 @@ struct TestDriver {
         refImpl.check(reads, results2, numPointReads + numRangeReads);
       }
 
-      auto compareResults = [reads](ConflictSet::Result *results1,
+      auto compareResults = [reads, this](ConflictSet::Result *results1,
-                                    ConflictSet::Result *results2, int count) {
+                                          ConflictSet::Result *results2,
+                                          int count) {
         for (int i = 0; i < count; ++i) {
           if (results1[i] != results2[i]) {
             if (reads[i].end.len == 0) {
-              fprintf(stderr,
-                      "Expected %s, got %s for read of {%s} at version %" PRId64
-                      "\n",
-                      resultToStr(results2[i]), resultToStr(results1[i]),
-                      printable(reads[i].begin).c_str(), reads[i].readVersion);
-            } else {
               fprintf(
                   stderr,
-                  "Expected %s, got %s for read of [%s, %s) at version %" PRId64
+                  "%p Expected %s, got %s for read of {%s} at version %" PRId64
                   "\n",
-                  resultToStr(results2[i]), resultToStr(results1[i]),
+                  (void *)this, resultToStr(results2[i]),
-                  printable(reads[i].begin).c_str(),
+                  resultToStr(results1[i]), printable(reads[i].begin).c_str(),
-                  printable(reads[i].end).c_str(), reads[i].readVersion);
+                  reads[i].readVersion);
+            } else {
+              fprintf(stderr,
+                      "%p Expected %s, got %s for read of [%s, %s) at version "
+                      "%" PRId64 "\n",
+                      (void *)this, resultToStr(results2[i]),
+                      resultToStr(results1[i]),
+                      printable(reads[i].begin).c_str(),
+                      printable(reads[i].end).c_str(), reads[i].readVersion);
             }
             return false;
           }

Jenkinsfile

@@ -123,8 +123,8 @@ pipeline {
                 '''
                 recordCoverage qualityGates: [[criticality: 'NOTE', metric: 'MODULE']], tools: [[parser: 'COBERTURA', pattern: 'build/coverage.xml']]
                 sh '''
-                # Suppress again, because we haven't dealt with function multi-versioning for x86 yet
+                gcovr -f ConflictSet.cpp
-                # gcovr -f ConflictSet.cpp --fail-under-line 100 > /dev/null
+                gcovr -f ConflictSet.cpp --fail-under-line 100 > /dev/null
                 '''
             }
         }

README.md

@@ -73,14 +73,14 @@ Performance counters:
 
 |               ns/op |                op/s |    err% |     total | benchmark
 |--------------------:|--------------------:|--------:|----------:|:----------
-|               19.17 |       52,163,930.66 |    0.1% |      0.01 | `point reads`
+|               20.25 |       49,372,759.86 |    0.3% |      0.01 | `point reads`
-|               23.68 |       42,224,388.21 |    0.7% |      0.01 | `prefix reads`
+|               23.58 |       42,401,298.00 |    0.3% |      0.01 | `prefix reads`
-|               63.30 |       15,797,506.06 |    0.9% |      0.01 | `range reads`
+|               64.12 |       15,595,463.14 |    0.8% |      0.01 | `range reads`
-|               29.66 |       33,720,994.74 |    0.3% |      0.01 | `point writes`
+|               29.50 |       33,903,101.20 |    0.7% |      0.01 | `point writes`
-|               43.50 |       22,987,781.25 |    1.0% |      0.01 | `prefix writes`
+|               46.76 |       21,384,036.19 |    1.2% |      0.01 | `prefix writes`
-|               50.00 |       20,000,000.00 |    0.8% |      0.01 | `range writes`
+|               51.25 |       19,512,195.12 |    0.0% |      0.01 | `range writes`
-|              103.25 |        9,684,786.47 |    2.9% |      0.01 | `monotonic increasing point writes`
+|              109.51 |        9,131,469.31 |    3.6% |      0.01 | `monotonic increasing point writes`
-|        1,181,500.00 |              846.38 |    2.3% |      0.01 | `worst case for radix tree`
+|        1,153,875.00 |              866.65 |    1.6% |      0.01 | `worst case for radix tree`
 
 # "Real data" test
 
@@ -95,7 +95,7 @@ Check: 11.3385 seconds, 329.718 MB/s, Add: 5.35612 seconds, 131.072 MB/s, Gc rat
 ## radix tree
 
 ```
-Check: 2.48583 seconds, 1503.93 MB/s, Add: 2.12768 seconds, 329.954 MB/s, Gc ratio: 41.7943%
+Check: 2.60639 seconds, 1434.36 MB/s, Add: 2.10911 seconds, 332.86 MB/s, Gc ratio: 46.3071%
 ```
 
 ## hash table

SkipList.cpp

@@ -778,10 +778,6 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     for (int s = stripes - 1; s >= 0; s--) {
       for (int i = 0; i * 2 < ss; ++i) {
         const auto &w = combinedWriteConflictRanges[s * stripeSize / 2 + i];
-#if DEBUG_VERBOSE
-        printf("Write begin: %s\n", printable(w.begin).c_str());
-        fflush(stdout);
-#endif
         values[i * 2] = w.first;
         values[i * 2 + 1] = w.second;
         keyUpdates += 3;

TestDriver.cpp

@@ -13,25 +13,58 @@ int main(int argc, char **argv) {
     std::stringstream buffer;
     buffer << t.rdbuf();
     auto str = buffer.str();
-    TestDriver<ConflictSet, !PERF_TEST> driver{(const uint8_t *)str.data(),
+    Arbitrary arbitrary({(const uint8_t *)str.data(), str.size()});
-                                               str.size()};
+    TestDriver<ConflictSet, !PERF_TEST> driver1{arbitrary};
-    while (!driver.next())
+    TestDriver<ConflictSet, !PERF_TEST> driver2{arbitrary};
-      ;
+    bool done1 = false;
-    if (!driver.ok) {
+    bool done2 = false;
-      abort();
+    for (;;) {
+      if (!done1) {
+        done1 = driver1.next();
+        if (!driver1.ok) {
+          abort();
+        }
+      }
+      if (!done2) {
+        done2 = driver2.next();
+        if (!driver2.ok) {
+          abort();
+        }
+      }
+      if (done1 && done2) {
+        break;
+      }
     }
 
-    ConflictSet::MetricsV1 *metrics;
+    {
-    int metricsCount;
+      ConflictSet::MetricsV1 *metrics;
-    driver.cs.getMetricsV1(&metrics, &metricsCount);
+      int metricsCount;
-    printf("#################### METRICS FOR %s ####################\n",
+      driver1.cs.getMetricsV1(&metrics, &metricsCount);
-           argv[i]);
+      printf("#################### METRICS for ConflictSet 1 for %s "
-    for (int i = 0; i < metricsCount; ++i) {
+             "####################\n",
-      printf("# HELP %s %s\n", metrics[i].name, metrics[i].help);
+             argv[i]);
-      printf("# TYPE %s %s\n", metrics[i].name,
+      for (int i = 0; i < metricsCount; ++i) {
-             metrics[i].type == metrics[i].Counter ? "counter" : "gauge");
+        printf("# HELP %s %s\n", metrics[i].name, metrics[i].help);
-      printf("%s %g\n", metrics[i].name, metrics[i].getValue());
+        printf("# TYPE %s %s\n", metrics[i].name,
+               metrics[i].type == metrics[i].Counter ? "counter" : "gauge");
+        printf("%s %g\n", metrics[i].name, metrics[i].getValue());
+      }
+      puts("");
+    }
+    {
+      ConflictSet::MetricsV1 *metrics;
+      int metricsCount;
+      driver2.cs.getMetricsV1(&metrics, &metricsCount);
+      printf("#################### METRICS for ConflictSet 2 for %s "
+             "####################\n",
+             argv[i]);
+      for (int i = 0; i < metricsCount; ++i) {
+        printf("# HELP %s %s\n", metrics[i].name, metrics[i].help);
+        printf("# TYPE %s %s\n", metrics[i].name,
+               metrics[i].type == metrics[i].Counter ? "counter" : "gauge");
+        printf("%s %g\n", metrics[i].name, metrics[i].getValue());
+      }
+      puts("");
     }
-    puts("");
   }
 }

aarch64-symbol-imports.txt

@@ -1,4 +1,4 @@
-__aarch64_cas8_relax
+__aarch64_ldadd8_relax
 __getauxval@GLIBC_2.17
 __stack_chk_fail@GLIBC_2.17
 __stack_chk_guard@GLIBC_2.17

corpus/0f5c5f28c31e44ee0ec085fec09adf0981065771

@@ -0,0 +1,5 @@
+
+<EFBFBD><EFBFBD>
+
+
+2

corpus/12bdd00fd4038756cbcf8ecdad1b0cd862603cd8

@@ -0,0 +1 @@
+<EFBFBD>