Compare commits
15
Commits
4bec2cf4eb
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
aeafce1bc8 | ||
|
|
cce3e1651f | ||
|
|
d7b4b66dd5 | ||
|
|
3d997d5c57 | ||
|
|
0ca1d3c546 | ||
|
|
b671f93e5a | ||
|
|
e23018c952 | ||
|
|
b1c1f8f2ee | ||
|
|
23d092ab69 | ||
|
|
84bf5707f9 | ||
|
|
c94e9aaee6 | ||
|
|
d71d963d9a | ||
|
|
dabddbcb56 | ||
|
|
3b4271dac1 | ||
|
|
3d3184ef5f |
No files matched your search
+1
-1
@@ -394,7 +394,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)
|
add_test(NAME conflict_set_cxx_api_test COMMAND conflict_set_cxx_api_test)
|
||||||
|
|
||||||
# SHOW_MEMORY instrumentation, which the rest of the test suite doesn't
|
# SHOW_MEMORY instrumentation, which the rest of the test suite doesn't
|
||||||
# compile with
|
# compile with. It assumes a single live ConflictSet (see Internal.h).
|
||||||
add_executable(conflict_set_show_memory_test ConflictSet.cpp
|
add_executable(conflict_set_show_memory_test ConflictSet.cpp
|
||||||
ShowMemoryTest.cpp)
|
ShowMemoryTest.cpp)
|
||||||
target_compile_options(conflict_set_show_memory_test PRIVATE ${TEST_FLAGS})
|
target_compile_options(conflict_set_show_memory_test PRIVATE ${TEST_FLAGS})
|
||||||
|
|||||||
+51
-9
@@ -118,13 +118,40 @@ struct InternalVersionT {
|
|||||||
constexpr InternalVersionT() = default;
|
constexpr InternalVersionT() = default;
|
||||||
constexpr explicit InternalVersionT(int64_t value) : value(value) {}
|
constexpr explicit InternalVersionT(int64_t value) : value(value) {}
|
||||||
constexpr int64_t toInt64() const { return value; } // GCOVR_EXCL_LINE
|
constexpr int64_t toInt64() const { return value; } // GCOVR_EXCL_LINE
|
||||||
constexpr auto operator<=>(const InternalVersionT &rhs) const {
|
constexpr bool operator<(const InternalVersionT &rhs) const {
|
||||||
#if USE_64_BIT
|
#if USE_64_BIT
|
||||||
return value <=> rhs.value;
|
return value < rhs.value;
|
||||||
#else
|
#else
|
||||||
// Maintains ordering after overflow, as long as the full-precision versions
|
// Maintains ordering after overflow, as long as the full-precision versions
|
||||||
// are within `kMaxCorrectVersionWindow` of eachother.
|
// are within `kMaxCorrectVersionWindow` of eachother.
|
||||||
return int32_t(value - rhs.value) <=> 0;
|
return int32_t(value - rhs.value) < 0;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
constexpr bool operator<=(const InternalVersionT &rhs) const {
|
||||||
|
#if USE_64_BIT
|
||||||
|
return value <= rhs.value;
|
||||||
|
#else
|
||||||
|
// Maintains ordering after overflow, as long as the full-precision versions
|
||||||
|
// are within `kMaxCorrectVersionWindow` of eachother.
|
||||||
|
return int32_t(value - rhs.value) <= 0;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
constexpr bool operator>=(const InternalVersionT &rhs) const {
|
||||||
|
#if USE_64_BIT
|
||||||
|
return value >= rhs.value;
|
||||||
|
#else
|
||||||
|
// Maintains ordering after overflow, as long as the full-precision versions
|
||||||
|
// are within `kMaxCorrectVersionWindow` of eachother.
|
||||||
|
return int32_t(value - rhs.value) >= 0;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
constexpr bool operator>(const InternalVersionT &rhs) const {
|
||||||
|
#if USE_64_BIT
|
||||||
|
return value > rhs.value;
|
||||||
|
#else
|
||||||
|
// Maintains ordering after overflow, as long as the full-precision versions
|
||||||
|
// are within `kMaxCorrectVersionWindow` of eachother.
|
||||||
|
return int32_t(value - rhs.value) > 0;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
constexpr bool operator==(const InternalVersionT &) const = default;
|
constexpr bool operator==(const InternalVersionT &) const = default;
|
||||||
@@ -2284,6 +2311,8 @@ bool checkMaxBetweenExclusiveImpl(Node3 *n, int begin, int end,
|
|||||||
assert(!(begin == -1 && end == 256));
|
assert(!(begin == -1 && end == 256));
|
||||||
|
|
||||||
auto *self = static_cast<Node3 *>(n);
|
auto *self = static_cast<Node3 *>(n);
|
||||||
|
assume(1 <= self->numChildren);
|
||||||
|
assume(self->numChildren <= 3);
|
||||||
|
|
||||||
++begin;
|
++begin;
|
||||||
|
|
||||||
@@ -2957,9 +2986,13 @@ void fixupMaxVersion(Node *node, WriteContext *writeContext) {
|
|||||||
break;
|
break;
|
||||||
case Type_Node3: {
|
case Type_Node3: {
|
||||||
auto *self3 = static_cast<Node3 *>(node);
|
auto *self3 = static_cast<Node3 *>(node);
|
||||||
max = std::max(max,
|
assume(1 <= self3->numChildren);
|
||||||
horizontalMaxUpTo16(self3->childMaxVersion,
|
assume(self3->numChildren <= 3);
|
||||||
writeContext->zero, self3->numChildren));
|
InternalVersionT m = self3->childMaxVersion[0];
|
||||||
|
for (int i = 1; i < self3->numChildren; ++i) {
|
||||||
|
m = std::max(m, self3->childMaxVersion[i]);
|
||||||
|
}
|
||||||
|
max = std::max(max, m);
|
||||||
} break;
|
} break;
|
||||||
case Type_Node16: {
|
case Type_Node16: {
|
||||||
auto *self16 = static_cast<Node16 *>(node);
|
auto *self16 = static_cast<Node16 *>(node);
|
||||||
@@ -5513,7 +5546,9 @@ void internal_addWrites(ConflictSet::Impl *impl,
|
|||||||
impl->totalBytes += mallocBytesDelta;
|
impl->totalBytes += mallocBytesDelta;
|
||||||
impl->memory_bytes.set(impl->totalBytes);
|
impl->memory_bytes.set(impl->totalBytes);
|
||||||
#if SHOW_MEMORY
|
#if SHOW_MEMORY
|
||||||
// Testing-only cross-check of the accounting.
|
// Testing-only cross-check of the accounting. `mallocBytes` is process-wide,
|
||||||
|
// while `impl->totalBytes` only covers this instance, so this holds only
|
||||||
|
// while this is the only live ConflictSet (see Internal.h).
|
||||||
if (impl->totalBytes != mallocBytes) {
|
if (impl->totalBytes != mallocBytes) {
|
||||||
abort(); // GCOVR_EXCL_LINE
|
abort(); // GCOVR_EXCL_LINE
|
||||||
}
|
}
|
||||||
@@ -5526,7 +5561,9 @@ void internal_setOldestVersion(ConflictSet::Impl *impl, int64_t oldestVersion) {
|
|||||||
impl->totalBytes += mallocBytesDelta;
|
impl->totalBytes += mallocBytesDelta;
|
||||||
impl->memory_bytes.set(impl->totalBytes);
|
impl->memory_bytes.set(impl->totalBytes);
|
||||||
#if SHOW_MEMORY
|
#if SHOW_MEMORY
|
||||||
// Testing-only cross-check of the accounting.
|
// Testing-only cross-check of the accounting. `mallocBytes` is process-wide,
|
||||||
|
// while `impl->totalBytes` only covers this instance, so this holds only
|
||||||
|
// while this is the only live ConflictSet (see Internal.h).
|
||||||
if (impl->totalBytes != mallocBytes) {
|
if (impl->totalBytes != mallocBytes) {
|
||||||
abort(); // GCOVR_EXCL_LINE
|
abort(); // GCOVR_EXCL_LINE
|
||||||
}
|
}
|
||||||
@@ -5598,6 +5635,9 @@ Node *firstGeqLogical(Node *n, const TrivialSpan key) {
|
|||||||
goto downLeftSpine;
|
goto downLeftSpine;
|
||||||
} else {
|
} else {
|
||||||
n = nextSibling(n);
|
n = nextSibling(n);
|
||||||
|
if (n == nullptr) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
goto downLeftSpine;
|
goto downLeftSpine;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -5895,7 +5935,9 @@ checkMaxVersion(Node *root, Node *node, InternalVersionT oldestVersion,
|
|||||||
expected = std::max(expected, child->entry.rangeVersion);
|
expected = std::max(expected, child->entry.rangeVersion);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
auto key = getSearchPath(root);
|
// Account for the range version of the first key after `node`'s subtree: a
|
||||||
|
// range write spanning the subtree is recorded there.
|
||||||
|
auto key = getSearchPath(node);
|
||||||
bool ok;
|
bool ok;
|
||||||
auto inc = strinc(key, ok);
|
auto inc = strinc(key, ok);
|
||||||
if (ok) {
|
if (ok) {
|
||||||
|
|||||||
@@ -96,6 +96,14 @@ static_assert(std::is_trivial_v<TrivialSpan>);
|
|||||||
// GCOVR_EXCL_START
|
// GCOVR_EXCL_START
|
||||||
|
|
||||||
#if SHOW_MEMORY
|
#if SHOW_MEMORY
|
||||||
|
// Process-wide by design: `safe_malloc`/`safe_free` update these for every
|
||||||
|
// allocation in the process, no matter which ConflictSet made it. An instance's
|
||||||
|
// `totalBytes`, in contrast, only accounts for the allocations made during its
|
||||||
|
// own API calls, so the SHOW_MEMORY cross-check of the two in
|
||||||
|
// `internal_addWrites`/`internal_setOldestVersion` only holds while a single
|
||||||
|
// ConflictSet is alive. Running several at once is supported by the library;
|
||||||
|
// SHOW_MEMORY just doesn't instrument it. `peakMallocBytes` is process-wide
|
||||||
|
// too, but as a peak it remains meaningful with several instances.
|
||||||
inline int64_t mallocBytes = 0;
|
inline int64_t mallocBytes = 0;
|
||||||
inline int64_t peakMallocBytes = 0;
|
inline int64_t peakMallocBytes = 0;
|
||||||
// Defined in ConflictSet.cpp
|
// Defined in ConflictSet.cpp
|
||||||
|
|||||||
+70
-2
@@ -96,7 +96,7 @@ inline int firstNeqStride(const uint8_t *ap, const uint8_t *bp) {
|
|||||||
// GCOVR_EXCL_START
|
// GCOVR_EXCL_START
|
||||||
#if defined(HAS_AVX) && !defined(__SANITIZE_THREAD__)
|
#if defined(HAS_AVX) && !defined(__SANITIZE_THREAD__)
|
||||||
__attribute__((target("avx512f,avx512bw"))) inline int
|
__attribute__((target("avx512f,avx512bw"))) inline int
|
||||||
longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
|
longestCommonPrefixLong(const uint8_t *ap, const uint8_t *bp, int cl) {
|
||||||
int i = 0;
|
int i = 0;
|
||||||
int end = cl & ~63;
|
int end = cl & ~63;
|
||||||
while (i < end) {
|
while (i < end) {
|
||||||
@@ -123,7 +123,7 @@ __attribute__((target("default")))
|
|||||||
// GCOVR_EXCL_STOP
|
// GCOVR_EXCL_STOP
|
||||||
|
|
||||||
inline int
|
inline int
|
||||||
longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
|
longestCommonPrefixLong(const uint8_t *ap, const uint8_t *bp, int cl) {
|
||||||
if (!(cl >= 0)) {
|
if (!(cl >= 0)) {
|
||||||
__builtin_unreachable(); // GCOVR_EXCL_LINE
|
__builtin_unreachable(); // GCOVR_EXCL_LINE
|
||||||
}
|
}
|
||||||
@@ -183,3 +183,71 @@ longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
|
|||||||
|
|
||||||
return i;
|
return i;
|
||||||
}
|
}
|
||||||
|
// Use in-bounds native-word loads for short common lengths. The second load
|
||||||
|
// overlaps the first; because the first load matched, any mismatch found in
|
||||||
|
// the overlap is impossible and the returned absolute index is still correct.
|
||||||
|
// Precondition: cl <= 2 * sizeof(uint64_t)
|
||||||
|
__attribute__((always_inline)) static inline int
|
||||||
|
longestCommonPrefixShort(const uint8_t *ap, const uint8_t *bp, int cl) {
|
||||||
|
assert(cl <= 2 * int(sizeof(uint64_t)));
|
||||||
|
if (cl >= 8) {
|
||||||
|
uint64_t a0;
|
||||||
|
uint64_t b0;
|
||||||
|
memcpy(&a0, ap, sizeof(a0));
|
||||||
|
memcpy(&b0, bp, sizeof(b0));
|
||||||
|
if (uint64_t mismatched = a0 ^ b0) {
|
||||||
|
return std::countr_zero(mismatched) / 8;
|
||||||
|
}
|
||||||
|
if (cl == 8) {
|
||||||
|
return 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t a1;
|
||||||
|
uint64_t b1;
|
||||||
|
memcpy(&a1, ap + cl - 8, sizeof(a1));
|
||||||
|
memcpy(&b1, bp + cl - 8, sizeof(b1));
|
||||||
|
if (uint64_t mismatched = a1 ^ b1) {
|
||||||
|
return cl - 8 + std::countr_zero(mismatched) / 8;
|
||||||
|
}
|
||||||
|
return cl;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cl >= 4) {
|
||||||
|
uint32_t a0;
|
||||||
|
uint32_t b0;
|
||||||
|
memcpy(&a0, ap, sizeof(a0));
|
||||||
|
memcpy(&b0, bp, sizeof(b0));
|
||||||
|
if (uint32_t mismatched = a0 ^ b0) {
|
||||||
|
return std::countr_zero(mismatched) / 8;
|
||||||
|
}
|
||||||
|
if (cl == 4) {
|
||||||
|
return 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t a1;
|
||||||
|
uint32_t b1;
|
||||||
|
memcpy(&a1, ap + cl - 4, sizeof(a1));
|
||||||
|
memcpy(&b1, bp + cl - 4, sizeof(b1));
|
||||||
|
if (uint32_t mismatched = a1 ^ b1) {
|
||||||
|
return cl - 4 + std::countr_zero(mismatched) / 8;
|
||||||
|
}
|
||||||
|
return cl;
|
||||||
|
}
|
||||||
|
|
||||||
|
int i = 0;
|
||||||
|
while (i < cl && ap[i] == bp[i]) {
|
||||||
|
++i;
|
||||||
|
}
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((always_inline)) static inline int
|
||||||
|
longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
|
||||||
|
if (!(cl >= 0)) {
|
||||||
|
__builtin_unreachable(); // GCOVR_EXCL_LINE
|
||||||
|
}
|
||||||
|
if (cl <= 2 * int(sizeof(uint64_t))) {
|
||||||
|
return longestCommonPrefixShort(ap, bp, cl);
|
||||||
|
}
|
||||||
|
return longestCommonPrefixLong(ap, bp, cl);
|
||||||
|
}
|
||||||
@@ -19,30 +19,30 @@ InstalledDir: /usr/lib/llvm-21/bin
|
|||||||
|
|
||||||
| ns/op | op/s | err% | ins/op | cyc/op | IPC | bra/op | miss% | total | benchmark
|
| ns/op | op/s | err% | ins/op | cyc/op | IPC | bra/op | miss% | total | benchmark
|
||||||
|--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
|
|--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
|
||||||
| 164.29 | 6,086,873.38 | 0.0% | 3,107.03 | 604.19 | 5.142 | 558.59 | 0.0% | 1.96 | `point reads`
|
| 165.93 | 6,026,520.04 | 0.1% | 3,107.03 | 610.42 | 5.090 | 558.59 | 0.0% | 1.98 | `point reads`
|
||||||
| 161.05 | 6,209,395.38 | 0.1% | 3,036.76 | 592.21 | 5.128 | 539.35 | 0.0% | 1.93 | `prefix reads`
|
| 163.08 | 6,132,046.57 | 0.1% | 3,036.76 | 599.68 | 5.064 | 539.35 | 0.0% | 1.95 | `prefix reads`
|
||||||
| 239.55 | 4,174,539.38 | 0.1% | 3,722.71 | 880.68 | 4.227 | 692.00 | 0.0% | 2.86 | `range reads`
|
| 250.26 | 3,995,834.21 | 0.1% | 3,722.71 | 920.25 | 4.045 | 692.00 | 0.0% | 2.99 | `range reads`
|
||||||
| 354.75 | 2,818,919.14 | 0.7% | 4,523.64 | 1,304.75 | 3.467 | 720.22 | 2.0% | 4.23 | `point writes`
|
| 359.64 | 2,780,581.63 | 0.1% | 4,523.64 | 1,322.63 | 3.420 | 720.22 | 2.1% | 4.30 | `point writes`
|
||||||
| 345.32 | 2,895,878.47 | 0.1% | 4,484.57 | 1,270.31 | 3.530 | 705.00 | 1.8% | 4.12 | `prefix writes`
|
| 358.20 | 2,791,726.93 | 0.1% | 4,484.57 | 1,317.23 | 3.405 | 705.00 | 2.0% | 4.28 | `prefix writes`
|
||||||
| 193.48 | 5,168,547.42 | 0.1% | 2,224.10 | 711.72 | 3.125 | 377.17 | 3.3% | 2.32 | `range writes`
|
| 193.91 | 5,157,081.29 | 0.1% | 2,224.10 | 713.33 | 3.118 | 377.17 | 3.3% | 2.32 | `range writes`
|
||||||
| 404.89 | 2,469,777.50 | 2.4% | 6,855.96 | 1,489.70 | 4.602 | 1,227.82 | 1.3% | 0.05 | `monotonic increasing point writes`
|
| 422.03 | 2,369,513.38 | 1.1% | 6,855.96 | 1,551.55 | 4.419 | 1,227.82 | 1.4% | 0.05 | `monotonic increasing point writes`
|
||||||
| 134,231.80 | 7,449.80 | 1.9% | 812,045.25 | 495,770.40 | 1.638 | 151,246.50 | 0.9% | 0.01 | `worst case for radix tree`
|
| 142,467.00 | 7,019.17 | 3.8% | 812,047.33 | 508,535.40 | 1.597 | 151,246.50 | 1.0% | 0.01 | `worst case for radix tree`
|
||||||
| 37.80 | 26,454,311.17 | 0.4% | 701.00 | 139.14 | 5.038 | 102.00 | 0.0% | 0.01 | `create and destroy`
|
| 37.66 | 26,554,217.74 | 0.8% | 701.00 | 138.80 | 5.050 | 102.00 | 0.0% | 0.01 | `create and destroy`
|
||||||
|
|
||||||
## Radix tree (this implementation)
|
## Radix tree (this implementation)
|
||||||
|
|
||||||
|
|
||||||
| ns/op | op/s | err% | ins/op | cyc/op | IPC | bra/op | miss% | total | benchmark
|
| ns/op | op/s | err% | ins/op | cyc/op | IPC | bra/op | miss% | total | benchmark
|
||||||
|--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
|
|--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
|
||||||
| 12.89 | 77,565,115.56 | 0.1% | 244.55 | 47.43 | 5.155 | 34.21 | 0.6% | 0.15 | `point reads`
|
| 12.25 | 81,664,669.29 | 0.4% | 233.49 | 44.94 | 5.196 | 31.23 | 0.7% | 0.15 | `point reads`
|
||||||
| 15.11 | 66,162,047.76 | 0.1% | 297.79 | 55.60 | 5.356 | 43.23 | 0.4% | 0.18 | `prefix reads`
|
| 13.35 | 74,903,950.49 | 0.1% | 271.75 | 49.10 | 5.534 | 40.21 | 0.4% | 0.16 | `prefix reads`
|
||||||
| 36.29 | 27,559,358.29 | 0.1% | 783.16 | 133.44 | 5.869 | 109.52 | 0.2% | 0.43 | `range reads`
|
| 31.37 | 31,874,583.62 | 0.1% | 700.39 | 115.43 | 6.067 | 100.83 | 0.2% | 0.37 | `range reads`
|
||||||
| 20.53 | 48,719,405.55 | 0.1% | 381.81 | 75.51 | 5.057 | 51.04 | 0.5% | 0.25 | `point writes`
|
| 19.55 | 51,153,057.80 | 0.1% | 366.51 | 71.90 | 5.098 | 47.92 | 0.5% | 0.23 | `point writes`
|
||||||
| 39.37 | 25,402,042.40 | 0.1% | 685.00 | 144.83 | 4.730 | 106.72 | 0.3% | 0.47 | `prefix writes`
|
| 36.92 | 27,088,344.17 | 0.1% | 645.11 | 135.72 | 4.753 | 100.31 | 0.4% | 0.44 | `prefix writes`
|
||||||
| 43.78 | 22,843,841.63 | 0.1% | 800.40 | 161.06 | 4.970 | 127.36 | 0.1% | 0.53 | `range writes`
|
| 36.84 | 27,143,553.08 | 0.1% | 691.04 | 135.42 | 5.103 | 114.01 | 0.1% | 0.45 | `range writes`
|
||||||
| 78.37 | 12,760,008.75 | 1.0% | 1,452.61 | 288.24 | 5.040 | 278.69 | 0.1% | 0.01 | `monotonic increasing point writes`
|
| 74.62 | 13,400,467.72 | 0.9% | 1,418.37 | 274.20 | 5.173 | 273.39 | 0.1% | 0.01 | `monotonic increasing point writes`
|
||||||
| 322,885.50 | 3,097.07 | 1.5% | 4,362,382.00 | 1,183,852.00 | 3.685 | 765,301.00 | 0.1% | 0.01 | `worst case for radix tree`
|
| 352,671.00 | 2,835.50 | 15.3% | 3,687,535.00 | 1,287,119.00 | 2.865 | 712,030.00 | 0.1% | 0.01 | :wavy_dash: `worst case for radix tree` (Unstable with ~1.0 iters. Increase `minEpochIterations` to e.g. 10)
|
||||||
| 99.99 | 10,000,718.79 | 0.4% | 1,775.00 | 367.93 | 4.824 | 288.00 | 0.0% | 0.01 | `create and destroy`
|
| 96.63 | 10,348,729.42 | 1.2% | 1,766.00 | 355.53 | 4.967 | 283.00 | 0.0% | 0.01 | `create and destroy`
|
||||||
|
|
||||||
# "Real data" test
|
# "Real data" test
|
||||||
|
|
||||||
@@ -51,13 +51,13 @@ Point queries only. Gc ratio is the ratio of time spent doing garbage collection
|
|||||||
## skip list
|
## skip list
|
||||||
|
|
||||||
```
|
```
|
||||||
Check: 4.62967 seconds, 352.195 MB/s, Add: 3.34177 seconds, 167.771 MB/s, Gc ratio: 37.9399%, Peak idle memory: 5.51852e+06
|
Check: 4.69875 seconds, 347.017 MB/s, Add: 3.39475 seconds, 165.153 MB/s, Gc ratio: 38.7414%, Peak idle memory: 5.51852e+06
|
||||||
```
|
```
|
||||||
|
|
||||||
## radix tree
|
## radix tree
|
||||||
|
|
||||||
```
|
```
|
||||||
Check: 1.00477 seconds, 1622.8 MB/s, Add: 1.21142 seconds, 462.808 MB/s, Gc ratio: 39.4716%, Peak idle memory: 2.0226e+06
|
Check: 0.976745 seconds, 1669.37 MB/s, Add: 1.20464 seconds, 465.411 MB/s, Gc ratio: 39.4158%, Peak idle memory: 2.0226e+06
|
||||||
```
|
```
|
||||||
|
|
||||||
## hash table
|
## hash table
|
||||||
@@ -65,6 +65,6 @@ Check: 1.00477 seconds, 1622.8 MB/s, Add: 1.21142 seconds, 462.808 MB/s, Gc rati
|
|||||||
(The hash table implementation doesn't work on range queries, and its purpose is to provide an idea of how fast point queries can be)
|
(The hash table implementation doesn't work on range queries, and its purpose is to provide an idea of how fast point queries can be)
|
||||||
|
|
||||||
```
|
```
|
||||||
Check: 0.854254 seconds, 1908.74 MB/s, Add: 0.632626 seconds, 886.232 MB/s, Gc ratio: 41.0827%, Peak idle memory: 0
|
Check: 0.864589 seconds, 1885.92 MB/s, Add: 0.634604 seconds, 883.47 MB/s, Gc ratio: 41.184%, Peak idle memory: 0
|
||||||
```
|
```
|
||||||
|
|
||||||
+3
-2
@@ -1,8 +1,9 @@
|
|||||||
// Exercises the SHOW_MEMORY instrumentation, which the other tests don't
|
// Exercises the SHOW_MEMORY instrumentation, which the other tests don't
|
||||||
// compile with (this target passes -DSHOW_MEMORY=1). The instrumentation has
|
// compile with (this target passes -DSHOW_MEMORY=1). The instrumentation has
|
||||||
// its own consistency checks, which abort on failure, and asserts are enabled
|
// its own consistency checks, which abort on failure, and asserts are enabled
|
||||||
// by TEST_FLAGS. Only one ConflictSet may exist at a time, since the
|
// by TEST_FLAGS. Only one ConflictSet may exist at a time: the accounting is
|
||||||
// accounting is process-wide.
|
// process-wide, while the cross-check compares it against a single instance's
|
||||||
|
// totals (see the comment on `mallocBytes` in Internal.h).
|
||||||
#include "ConflictSet.h"
|
#include "ConflictSet.h"
|
||||||
#include "Internal.h"
|
#include "Internal.h"
|
||||||
|
|
||||||
|
|||||||
+22
-4
@@ -31,7 +31,9 @@
|
|||||||
std::span<const uint8_t> keyAfter(Arena &arena, std::span<const uint8_t> key) {
|
std::span<const uint8_t> keyAfter(Arena &arena, std::span<const uint8_t> key) {
|
||||||
auto result =
|
auto result =
|
||||||
std::span<uint8_t>(new (arena) uint8_t[key.size() + 1], key.size() + 1);
|
std::span<uint8_t>(new (arena) uint8_t[key.size() + 1], key.size() + 1);
|
||||||
memcpy(result.data(), key.data(), key.size());
|
if (key.size() > 0) {
|
||||||
|
memcpy(result.data(), key.data(), key.size());
|
||||||
|
}
|
||||||
result[result.size() - 1] = 0;
|
result[result.size() - 1] = 0;
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
@@ -50,6 +52,14 @@ using Version = int64_t;
|
|||||||
#define force_inline inline __attribute__((always_inline))
|
#define force_inline inline __attribute__((always_inline))
|
||||||
using StringRef = std::span<const uint8_t>;
|
using StringRef = std::span<const uint8_t>;
|
||||||
|
|
||||||
|
// memcmp, but safe for zero-length ranges: memcmp is undefined behavior unless
|
||||||
|
// both pointers are valid, even when the count is 0, and spans for the empty
|
||||||
|
// key are allowed to have a null data().
|
||||||
|
static force_inline bool equalBytes(const uint8_t *a, const uint8_t *b,
|
||||||
|
int size) {
|
||||||
|
return size == 0 || memcmp(a, b, size) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
struct KeyRangeRef {
|
struct KeyRangeRef {
|
||||||
StringRef begin;
|
StringRef begin;
|
||||||
StringRef end;
|
StringRef end;
|
||||||
@@ -180,7 +190,8 @@ void sortPoints(std::vector<KeyInfo> &points) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
static int compare(const StringRef &a, const StringRef &b) {
|
static int compare(const StringRef &a, const StringRef &b) {
|
||||||
int c = memcmp(a.data(), b.data(), std::min(a.size(), b.size()));
|
int n = std::min(a.size(), b.size());
|
||||||
|
int c = n > 0 ? memcmp(a.data(), b.data(), n) : 0;
|
||||||
if (c < 0)
|
if (c < 0)
|
||||||
return -1;
|
return -1;
|
||||||
if (c > 0)
|
if (c > 0)
|
||||||
@@ -371,7 +382,7 @@ public:
|
|||||||
Node *n = finger[0]->getNext(
|
Node *n = finger[0]->getNext(
|
||||||
0); // or alreadyChecked, but that is more easily invalidated
|
0); // or alreadyChecked, but that is more easily invalidated
|
||||||
if (n && n->length() == value.size() &&
|
if (n && n->length() == value.size() &&
|
||||||
!memcmp(n->value(), value.data(), value.size()))
|
equalBytes(n->value(), value.data(), value.size()))
|
||||||
return n;
|
return n;
|
||||||
else
|
else
|
||||||
return nullptr;
|
return nullptr;
|
||||||
@@ -695,7 +706,8 @@ private:
|
|||||||
s = nextS;
|
s = nextS;
|
||||||
if (start.finished()) {
|
if (start.finished()) {
|
||||||
if (nextS->length() == start.value.size() &&
|
if (nextS->length() == start.value.size() &&
|
||||||
!memcmp(nextS->value(), start.value.data(), start.value.size()))
|
equalBytes(nextS->value(), start.value.data(),
|
||||||
|
start.value.size()))
|
||||||
return noConflict();
|
return noConflict();
|
||||||
else
|
else
|
||||||
return conflict();
|
return conflict();
|
||||||
@@ -915,6 +927,9 @@ void internal_addWrites(ConflictSet::Impl *impl,
|
|||||||
impl->totalBytes += mallocBytesDelta;
|
impl->totalBytes += mallocBytesDelta;
|
||||||
impl->memory_bytes.set(impl->totalBytes);
|
impl->memory_bytes.set(impl->totalBytes);
|
||||||
#if SHOW_MEMORY
|
#if SHOW_MEMORY
|
||||||
|
// Testing-only cross-check of the accounting. `mallocBytes` is process-wide,
|
||||||
|
// while `impl->totalBytes` only covers this instance, so this holds only
|
||||||
|
// while this is the only live ConflictSet (see Internal.h).
|
||||||
if (impl->totalBytes != mallocBytes) {
|
if (impl->totalBytes != mallocBytes) {
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
@@ -927,6 +942,9 @@ void internal_setOldestVersion(ConflictSet::Impl *impl, int64_t oldestVersion) {
|
|||||||
impl->totalBytes += mallocBytesDelta;
|
impl->totalBytes += mallocBytesDelta;
|
||||||
impl->memory_bytes.set(impl->totalBytes);
|
impl->memory_bytes.set(impl->totalBytes);
|
||||||
#if SHOW_MEMORY
|
#if SHOW_MEMORY
|
||||||
|
// Testing-only cross-check of the accounting. `mallocBytes` is process-wide,
|
||||||
|
// while `impl->totalBytes` only covers this instance, so this holds only
|
||||||
|
// while this is the only live ConflictSet (see Internal.h).
|
||||||
if (impl->totalBytes != mallocBytes) {
|
if (impl->totalBytes != mallocBytes) {
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
|
|||||||
+31
-5
@@ -1,4 +1,6 @@
|
|||||||
import struct
|
import struct
|
||||||
|
|
||||||
|
import conflict_set
|
||||||
from conflict_set import *
|
from conflict_set import *
|
||||||
|
|
||||||
|
|
||||||
@@ -251,13 +253,37 @@ def test_merge_child_node48():
|
|||||||
cs.addWrites(1, write(b"\x00" * 8, b"\x00" * 10))
|
cs.addWrites(1, write(b"\x00" * 8, b"\x00" * 10))
|
||||||
|
|
||||||
|
|
||||||
def test_fixup_256():
|
def test_empty_key_null_pointer():
|
||||||
|
# Regression test for issue #96: the header only constrains the length of a
|
||||||
|
# key, so a zero-length key may be spelled with a null pointer. Both
|
||||||
|
# implementations must agree on such a key, and must not pass the null
|
||||||
|
# pointer to memcpy/memcmp, which is undefined behavior even when the length
|
||||||
|
# is 0 (keyAfter() in SkipList.cpp did, on every empty-key point operation).
|
||||||
|
null_key = conflict_set._Key(None, 0)
|
||||||
|
with DebugConflictSet() as cs:
|
||||||
|
cs.addWrites(1, WriteRange(null_key, null_key))
|
||||||
|
assert cs.check(ReadRange(null_key, null_key, 0)) == [Result.CONFLICT]
|
||||||
|
assert cs.check(ReadRange(null_key, null_key, 1)) == [Result.COMMIT]
|
||||||
|
|
||||||
|
# The same operations spelled with a non-null empty key must agree.
|
||||||
|
with DebugConflictSet() as cs:
|
||||||
|
cs.addWrites(1, write(b""))
|
||||||
|
assert cs.check(read(0, b"")) == [Result.CONFLICT]
|
||||||
|
assert cs.check(read(1, b"")) == [Result.COMMIT]
|
||||||
|
|
||||||
|
|
||||||
|
def test_fixup_256_heterogeneous_versions():
|
||||||
|
# Regression test for issue #89: recomputing the maxVersion of a Node256
|
||||||
|
# must consider all of its children, not just those with an index < 16.
|
||||||
|
# Here the highest-version child ("\x10\x50") has an index >= 16, and the
|
||||||
|
# range write ends at the Node256, which erases that child from the range
|
||||||
|
# and recomputes the Node256's maxVersion.
|
||||||
with DebugConflictSet() as cs:
|
with DebugConflictSet() as cs:
|
||||||
cs.addWrites(0, write(bytes([1])))
|
|
||||||
for i in range(256):
|
for i in range(256):
|
||||||
cs.addWrites(1, write(bytes([1, i])))
|
cs.addWrites(1, write(bytes([0x10, i])))
|
||||||
cs.addWrites(2, write(bytes([0]), bytes([1])))
|
cs.addWrites(10, write(bytes([0x10, 0x50])))
|
||||||
cs.check(read(0, bytes([1]), bytes([2])))
|
cs.addWrites(11, write(bytes([0x05]), bytes([0x10])))
|
||||||
|
assert cs.check(read(5, bytes([0x10, 0x50]))) == [Result.CONFLICT]
|
||||||
|
|
||||||
|
|
||||||
def test_large_removal_buffer():
|
def test_large_removal_buffer():
|
||||||
|
|||||||
+2
-1
@@ -1,7 +1,8 @@
|
|||||||
#!/bin/bash
|
#!/bin/bash
|
||||||
|
|
||||||
# Disable frequency scaling
|
# Disable frequency scaling
|
||||||
for i in $(seq "$(nproc)") ; do sudo cat /sys/devices/system/cpu/cpu$((i-1))/cpufreq/scaling_max_freq | sudo tee /sys/devices/system/cpu/cpu$((i-1))/cpufreq/scaling_min_freq >/dev/null ; done
|
# shellcheck disable=SC2002
|
||||||
|
for i in $(seq "$(nproc)") ; do cat /sys/devices/system/cpu/cpu$((i-1))/cpufreq/scaling_max_freq | sudo tee /sys/devices/system/cpu/cpu$((i-1))/cpufreq/scaling_min_freq >/dev/null ; done
|
||||||
|
|
||||||
cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=clang++ -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_CXX_FLAGS=-DNVALGRIND > /dev/null
|
cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=clang++ -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_CXX_FLAGS=-DNVALGRIND > /dev/null
|
||||||
cmake --build build > /dev/null
|
cmake --build build > /dev/null
|
||||||
|
|||||||
Reference in new issue
Block a user