weaselab/conflict-set
2
0
Fork 0
Code Issues 4 Packages Releases 13 Activity

Convert checkRangeRead to IteratorBase

Browse Source
This commit is contained in:
Andrew Noyes
2024-11-22 16:03:15 -08:00
parent 0619b6325c
commit 7972ed919b
1 changed files with 180 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
ConflictSet.cpp
View File

@@ -1891,6 +1891,8 @@ template <class T> struct Iterator;
// an entry associated with a node or a leaf.
struct IteratorBase {
IteratorBase() = default;
explicit IteratorBase(Node *node)
: node(node), type(node ? node->getType() : Type_Node0) {}
@@ -1928,6 +1930,8 @@ struct IteratorBase {
IteratorBase nextLogical();
IteratorBase nextPhysical();
InternalVersionT getMaxVersion();
IteratorBase parent() { return IteratorBase{node->parent}; }
uint8_t parentsIndex() { return node->parentsIndex; }
InternalVersionT exchangeMaxVersion(InternalVersionT);
InternalVersionT setMaxVersion();
TrivialSpan partialKey();
@@ -1936,7 +1940,11 @@ struct IteratorBase {
struct ChildAndMaxVersion;
ChildAndMaxVersion getChildAndMaxVersion(int index);
IteratorBase getChildGeq(int index);
IteratorBase getChild(int index);
IteratorBase nextSibling();
TrivialSpan getSearchPath(Arena &arena);
Node *escapeHatch() { return node; }
protected:
Node *node;
@@ -1963,9 +1971,14 @@ template <class T> struct Iterator : IteratorBase {
IteratorBase getChildGeq(int index) {
return IteratorBase{::getChildGeq(static_cast<T *>(node), index)};
}
IteratorBase getChild(int index) {
return IteratorBase{::getChild(static_cast<T *>(node), index)};
}
TrivialSpan partialKey() {
return {static_cast<T *>(node)->partialKey(), node->partialKeyLen};
}
T *escapeHatch() { return static_cast<T *>(node); }
};
TrivialSpan IteratorBase::partialKey() {
@@ -2037,6 +2050,23 @@ IteratorBase IteratorBase::getChildGeq(int index) {
}
}
IteratorBase IteratorBase::getChild(int index) {
switch (type) {
case Type_Node0:
return as<Node0>().getChild(index);
case Type_Node3:
return as<Node3>().getChild(index);
case Type_Node16:
return as<Node16>().getChild(index);
case Type_Node48:
return as<Node48>().getChild(index);
case Type_Node256:
return as<Node256>().getChild(index);
default: // GCOVR_EXCL_LINE
__builtin_unreachable(); // GCOVR_EXCL_LINE
}
}
InternalVersionT IteratorBase::getMaxVersion() { return ::maxVersion(node); }
bool IteratorBase::checkRangeVersionOfFirstGeq(InternalVersionT readVersion) {
@@ -2049,6 +2079,26 @@ IteratorBase IteratorBase::nextSibling() {
return IteratorBase{::nextSibling(node)};
}
TrivialSpan IteratorBase::getSearchPath(Arena &arena) {
Node *n = node;
assert(n != nullptr);
auto result = vector<uint8_t>(arena);
for (;;) {
for (int i = n->partialKeyLen - 1; i >= 0; --i) {
result.push_back(n->partialKey()[i]);
}
result.push_back(n->parentsIndex);
n = n->parent;
if (n->parent == nullptr) {
// Implicit byte from rootParent
result.pop_back();
break;
}
}
std::reverse(result.begin(), result.end());
return {result.begin(), result.size()};
}
// Precondition: self is not the root. May invalidate nodes along the search
// path to self. May invalidate children of self->parent. Returns a pointer to
// the node after self. Precondition: `self->entryPresent`
@@ -2792,58 +2842,58 @@ TrivialSpan getSearchPath(Arena &arena, Node *n) {
// Precondition: transitively, no child of n has a search path that's a longer
// prefix of key than n
template <class NodeT>
bool checkRangeStartsWith(NodeT *nTyped, TrivialSpan key, int begin, int end,
InternalVersionT readVersion,
bool checkRangeStartsWith(Iterator<NodeT> nTyped, TrivialSpan key, int begin,
int end, InternalVersionT readVersion,
ReadContext *readContext) {
Node *n;
IteratorBase n;
#if DEBUG_VERBOSE && !defined(NDEBUG)
fprintf(stderr, "%s(%02x,%02x)*\n", printable(key).c_str(), begin, end);
#endif
auto remaining = key;
if (remaining.size() == 0) {
return checkMaxBetweenExclusive(nTyped, begin, end, readVersion,
readContext);
return checkMaxBetweenExclusive(nTyped.escapeHatch(), begin, end,
readVersion, readContext);
}
auto cAndV = getChildAndMaxVersion(nTyped, remaining[0]);
Node *child = cAndV.child;
if (child == nullptr) {
auto c = getChildGeq(nTyped, remaining[0]);
if (c != nullptr) {
n = c;
return checkRangeVersionOfFirstGeq(n, readVersion);
auto cAndV = nTyped.getChildAndMaxVersion(remaining[0]);
IteratorBase child = cAndV.child;
if (!child.valid()) {
auto c = nTyped.getChildGeq(remaining[0]);
if (c.valid()) {
return c.checkRangeVersionOfFirstGeq(readVersion);
} else {
n = nextSibling(nTyped);
if (n == nullptr) {
n = nTyped.nextSibling();
if (!n.valid()) {
return true;
}
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
n = child;
remaining = remaining.subspan(1, remaining.size() - 1);
assert(n->partialKeyLen > 0);
auto partialKey = n.partialKey();
assert(partialKey.size() > 0);
{
int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
int commonLen = std::min<int>(partialKey.size(), remaining.size());
int i = longestCommonPrefix(partialKey.data(), remaining.data(), commonLen);
if (i < commonLen) {
auto c = n->partialKey()[i] <=> remaining[i];
auto c = partialKey[i] <=> remaining[i];
if (c > 0) {
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
} else {
n = nextSibling(n);
if (n == nullptr) {
n = n.nextSibling();
if (!n.valid()) {
return true;
}
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
assert(n->partialKeyLen > remaining.size());
if (begin < n->partialKey()[remaining.size()] &&
n->partialKey()[remaining.size()] < end) {
if (n->entryPresent && n->entry.rangeVersion > readVersion) {
assert(partialKey.size() > remaining.size());
if (begin < partialKey[remaining.size()] &&
partialKey[remaining.size()] < end) {
if (n.entryPresent() && n.getEntry().rangeVersion > readVersion) {
return false;
}
return cAndV.maxVersion <= readVersion;
@@ -2854,6 +2904,30 @@ bool checkRangeStartsWith(NodeT *nTyped, TrivialSpan key, int begin, int end,
__builtin_unreachable(); // GCOVR_EXCL_LINE
}
bool checkRangeStartsWith(IteratorBase n, TrivialSpan key, int begin, int end,
InternalVersionT readVersion,
ReadContext *readContext) {
switch (n.getType()) {
case Type_Node0:
return checkRangeStartsWith(n.as<Node0>(), key, begin, end, readVersion,
readContext);
case Type_Node3:
return checkRangeStartsWith(n.as<Node3>(), key, begin, end, readVersion,
readContext);
case Type_Node16:
return checkRangeStartsWith(n.as<Node16>(), key, begin, end, readVersion,
readContext);
case Type_Node48:
return checkRangeStartsWith(n.as<Node48>(), key, begin, end, readVersion,
readContext);
case Type_Node256:
return checkRangeStartsWith(n.as<Node256>(), key, begin, end, readVersion,
readContext);
default: // GCOVR_EXCL_LINE
__builtin_unreachable(); // GCOVR_EXCL_LINE
}
}
#ifdef __x86_64__
// Explicitly instantiate with target avx512f attribute so the compiler can
// inline compare16_32bit_avx512, and generally use avx512f within more
@@ -3723,7 +3797,8 @@ PRESERVE_NONE void done_common_prefix_iter(Job *job, Context *context) {
// If this were not true we would have returned above
assert(job->begin.size() > 0);
if (!checkRangeStartsWith(n, job->begin.subspan(0, job->lcp),
if (!checkRangeStartsWith(IteratorBase{n}.as<NodeT>(),
job->begin.subspan(0, job->lcp),
job->begin[job->lcp], job->end[job->lcp],
job->readVersion, &context->readContext)) {
job->setResult(false);
@@ -4689,7 +4764,7 @@ bool checkPrefixRead(IteratorBase n, const TrivialSpan key,
// Return true if the max version among all keys that start with key[:prefixLen]
// that are >= key is <= readVersion
bool checkRangeLeftSide(Node *n, TrivialSpan key, int prefixLen,
bool checkRangeLeftSide(IteratorBase n, TrivialSpan key, int prefixLen,
InternalVersionT readVersion,
ReadContext *readContext) {
auto remaining = key;
@@ -4697,33 +4772,32 @@ bool checkRangeLeftSide(Node *n, TrivialSpan key, int prefixLen,
for (;; ++readContext->range_read_iterations_accum) {
if (remaining.size() == 0) {
assert(searchPathLen >= prefixLen);
return maxVersion(n) <= readVersion;
return n.getMaxVersion() <= readVersion;
}
if (searchPathLen >= prefixLen) {
if (!checkMaxBetweenExclusive(n, remaining[0], 256, readVersion,
readContext)) {
if (!checkMaxBetweenExclusive(n.escapeHatch(), remaining[0], 256,
readVersion, readContext)) {
return false;
}
}
auto [c, maxV] = getChildAndMaxVersion(n, remaining[0]);
Node *child = c;
if (child == nullptr) {
auto c = getChildGeq(n, remaining[0]);
if (c != nullptr) {
auto [c, maxV] = n.getChildAndMaxVersion(remaining[0]);
IteratorBase child = c;
if (!child.valid()) {
auto c = n.getChildGeq(remaining[0]);
if (c.valid()) {
if (searchPathLen < prefixLen) {
n = c;
return checkRangeVersionOfFirstGeq(n, readVersion);
return c.checkRangeVersionOfFirstGeq(readVersion);
}
n = c;
return maxVersion(n) <= readVersion;
return n.getMaxVersion() <= readVersion;
} else {
n = nextSibling(n);
if (n == nullptr) {
n = n.nextSibling();
if (!n.valid()) {
return true;
}
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
@@ -4731,34 +4805,36 @@ bool checkRangeLeftSide(Node *n, TrivialSpan key, int prefixLen,
remaining = remaining.subspan(1, remaining.size() - 1);
++searchPathLen;
if (n->partialKeyLen > 0) {
int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
auto partialKey = n.partialKey();
if (partialKey.size() > 0) {
int commonLen = std::min<int>(partialKey.size(), remaining.size());
int i =
longestCommonPrefix(partialKey.data(), remaining.data(), commonLen);
searchPathLen += i;
if (i < commonLen) {
auto c = n->partialKey()[i] <=> remaining[i];
auto c = partialKey[i] <=> remaining[i];
if (c > 0) {
if (searchPathLen < prefixLen) {
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
if (n->entryPresent && n->entry.rangeVersion > readVersion) {
if (n.entryPresent() && n.getEntry().rangeVersion > readVersion) {
return false;
}
return maxV <= readVersion;
} else {
n = nextSibling(n);
if (n == nullptr) {
n = n.nextSibling();
if (!n.valid()) {
return true;
}
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
if (commonLen == n->partialKeyLen) {
if (commonLen == partialKey.size()) {
// partial key matches
remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
} else if (n->partialKeyLen > remaining.size()) {
} else if (partialKey.size() > remaining.size()) {
assert(searchPathLen >= prefixLen);
if (n->entryPresent && n->entry.rangeVersion > readVersion) {
if (n.entryPresent() && n.getEntry().rangeVersion > readVersion) {
return false;
}
return maxV <= readVersion;
@@ -4772,7 +4848,7 @@ bool checkRangeLeftSide(Node *n, TrivialSpan key, int prefixLen,
// Return true if the max version among all keys that start with key[:prefixLen]
// that are < key is <= readVersion
bool checkRangeRightSide(Node *n, TrivialSpan key, int prefixLen,
bool checkRangeRightSide(IteratorBase n, TrivialSpan key, int prefixLen,
InternalVersionT readVersion,
ReadContext *readContext) {
auto remaining = key;
@@ -4781,31 +4857,30 @@ bool checkRangeRightSide(Node *n, TrivialSpan key, int prefixLen,
for (;; ++readContext->range_read_iterations_accum) {
assert(searchPathLen <= key.size());
if (remaining.size() == 0) {
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
if (searchPathLen >= prefixLen) {
if (n->entryPresent && n->entry.pointVersion > readVersion) {
if (n.entryPresent() && n.getEntry().pointVersion > readVersion) {
return false;
}
if (!checkMaxBetweenExclusive(n, -1, remaining[0], readVersion,
readContext)) {
if (!checkMaxBetweenExclusive(n.escapeHatch(), -1, remaining[0],
readVersion, readContext)) {
return false;
}
}
if (searchPathLen > prefixLen && n->entryPresent &&
n->entry.rangeVersion > readVersion) {
if (searchPathLen > prefixLen && n.entryPresent() &&
n.getEntry().rangeVersion > readVersion) {
return false;
}
Node *child = getChild(n, remaining[0]);
if (child == nullptr) {
auto c = getChildGeq(n, remaining[0]);
if (c != nullptr) {
n = c;
return checkRangeVersionOfFirstGeq(n, readVersion);
IteratorBase child = n.getChild(remaining[0]);
if (!child.valid()) {
auto c = n.getChildGeq(remaining[0]);
if (c.valid()) {
return c.checkRangeVersionOfFirstGeq(readVersion);
} else {
goto backtrack;
}
@@ -4815,87 +4890,91 @@ bool checkRangeRightSide(Node *n, TrivialSpan key, int prefixLen,
remaining = remaining.subspan(1, remaining.size() - 1);
++searchPathLen;
if (n->partialKeyLen > 0) {
int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
auto partialKey = n.partialKey();
if (partialKey.size() > 0) {
int commonLen = std::min<int>(partialKey.size(), remaining.size());
int i =
longestCommonPrefix(partialKey.data(), remaining.data(), commonLen);
searchPathLen += i;
if (i < commonLen) {
++searchPathLen;
auto c = n->partialKey()[i] <=> remaining[i];
auto c = partialKey[i] <=> remaining[i];
if (c > 0) {
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
} else {
if (searchPathLen > prefixLen && n->entryPresent &&
n->entry.rangeVersion > readVersion) {
if (searchPathLen > prefixLen && n.entryPresent() &&
n.getEntry().rangeVersion > readVersion) {
return false;
}
goto backtrack;
}
}
if (commonLen == n->partialKeyLen) {
if (commonLen == partialKey.size()) {
// partial key matches
remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
} else if (n->partialKeyLen > remaining.size()) {
return checkRangeVersionOfFirstGeq(n, readVersion);
} else if (partialKey.size() > remaining.size()) {
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
}
backtrack:
for (;;) {
// searchPathLen > prefixLen implies n is not the root
if (searchPathLen > prefixLen && maxVersion(n) > readVersion) {
if (searchPathLen > prefixLen && n.getMaxVersion() > readVersion) {
return false;
}
if (n->parent == nullptr) {
if (!n.parent().valid()) {
return true;
}
auto next = getChildGeq(n->parent, n->parentsIndex + 1);
if (next == nullptr) {
searchPathLen -= 1 + n->partialKeyLen;
n = n->parent;
auto next = n.parent().getChildGeq(n.parentsIndex() + 1);
if (!next.valid()) {
searchPathLen -= 1 + n.partialKey().size();
n = n.parent();
} else {
n = next;
return checkRangeVersionOfFirstGeq(n, readVersion);
return n.checkRangeVersionOfFirstGeq(readVersion);
}
}
}
bool checkRangeRead(Node *n, TrivialSpan begin, TrivialSpan end,
bool checkRangeRead(IteratorBase n, TrivialSpan begin, TrivialSpan end,
InternalVersionT readVersion, ReadContext *readContext) {
int lcp = longestCommonPrefix(begin.data(), end.data(),
std::min(begin.size(), end.size()));
if (lcp == begin.size() && end.size() == begin.size() + 1 &&
end.back() == 0) {
return checkPointRead(IteratorBase{n}, begin, readVersion, readContext);
return checkPointRead(n, begin, readVersion, readContext);
}
if (lcp == begin.size() - 1 && end.size() == begin.size() &&
begin.back() + 1 == end.back()) {
return checkPrefixRead(IteratorBase{n}, begin, readVersion, readContext);
return checkPrefixRead(n, begin, readVersion, readContext);
}
++readContext->range_read_accum;
auto remaining = begin.subspan(0, lcp);
#ifndef NDEBUG
Arena arena;
#endif
// Advance down common prefix, but stay on a physical path in the tree
for (;; ++readContext->range_read_iterations_accum) {
assert(getSearchPath(arena, n) <=>
assert(n.getSearchPath(arena) <=>
begin.subspan(0, lcp - remaining.size()) ==
0);
if (remaining.size() == 0) {
break;
}
auto [c, v] = getChildAndMaxVersion(n, remaining[0]);
Node *child = c;
if (child == nullptr) {
auto [c, v] = n.getChildAndMaxVersion(remaining[0]);
IteratorBase child = c;
if (!child.valid()) {
break;
}
if (child->partialKeyLen > 0) {
int cl = std::min<int>(child->partialKeyLen, remaining.size() - 1);
int i =
longestCommonPrefix(child->partialKey(), remaining.data() + 1, cl);
if (i != child->partialKeyLen) {
auto partialKey = child.partialKey();
if (partialKey.size() > 0) {
int cl = std::min<int>(partialKey.size(), remaining.size() - 1);
int i = longestCommonPrefix(partialKey.data(), remaining.data() + 1, cl);
if (i != partialKey.size()) {
break;
}
}
@@ -4904,11 +4983,10 @@ bool checkRangeRead(Node *n, TrivialSpan begin, TrivialSpan end,
return true;
}
n = child;
remaining =
remaining.subspan(1 + child->partialKeyLen,
remaining.size() - (1 + child->partialKeyLen));
remaining = remaining.subspan(1 + partialKey.size(),
remaining.size() - (1 + partialKey.size()));
}
assert(getSearchPath(arena, n) <=> begin.subspan(0, lcp - remaining.size()) ==
assert(n.getSearchPath(arena) <=> begin.subspan(0, lcp - remaining.size()) ==
0);
const int consumed = lcp - remaining.size();
@@ -4946,7 +5024,7 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
InternalVersionT(reads[i].readVersion),
&context.readContext);
} else {
ok = checkRangeRead(rootParent->children[0],
ok = checkRangeRead(IteratorBase{rootParent->children[0]},
TrivialSpan(reads[i].begin.p, reads[i].begin.len),
TrivialSpan(reads[i].end.p, reads[i].end.len),
InternalVersionT(reads[i].readVersion),