597 lines
20 KiB
C++
597 lines
20 KiB
C++
/*
|
|
* WriteMap.cpp
|
|
*
|
|
* This source file is part of the FoundationDB open source project
|
|
*
|
|
* Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "fdbclient/WriteMap.h"
|
|
|
|
void OperationStack::reset(RYWMutation initialEntry) {
|
|
defaultConstructed = false;
|
|
singletonOperation = initialEntry;
|
|
optionalOperations = Optional<std::vector<RYWMutation>>();
|
|
}
|
|
|
|
void OperationStack::poppush(RYWMutation entry) {
|
|
if (hasVector()) {
|
|
optionalOperations.get().pop_back();
|
|
optionalOperations.get().push_back(entry);
|
|
} else
|
|
singletonOperation = entry;
|
|
}
|
|
|
|
void OperationStack::push(RYWMutation entry) {
|
|
if (defaultConstructed) {
|
|
singletonOperation = entry;
|
|
defaultConstructed = false;
|
|
} else if (hasVector())
|
|
optionalOperations.get().push_back(entry);
|
|
else {
|
|
optionalOperations = std::vector<RYWMutation>();
|
|
optionalOperations.get().push_back(entry);
|
|
}
|
|
}
|
|
|
|
bool OperationStack::isDependent() const {
|
|
if (!size())
|
|
return false;
|
|
return singletonOperation.type != MutationRef::SetValue && singletonOperation.type != MutationRef::ClearRange &&
|
|
singletonOperation.type != MutationRef::SetVersionstampedValue &&
|
|
singletonOperation.type != MutationRef::SetVersionstampedKey;
|
|
}
|
|
|
|
bool OperationStack::operator==(const OperationStack& r) const {
|
|
if (size() != r.size())
|
|
return false;
|
|
|
|
if (size() == 0)
|
|
return true;
|
|
|
|
if (singletonOperation != r.singletonOperation)
|
|
return false;
|
|
|
|
if (size() == 1)
|
|
return true;
|
|
|
|
for (int i = 0; i < optionalOperations.get().size(); i++) {
|
|
if (optionalOperations.get()[i] != r.optionalOperations.get()[i])
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
WriteMap& WriteMap::operator=(WriteMap&& r) noexcept {
|
|
writeMapEmpty = r.writeMapEmpty;
|
|
writes = std::move(r.writes);
|
|
ver = r.ver;
|
|
scratch_iterator = std::move(r.scratch_iterator);
|
|
arena = r.arena;
|
|
return *this;
|
|
}
|
|
|
|
void WriteMap::mutate(KeyRef key, MutationRef::Type operation, ValueRef param, bool addConflict) {
|
|
writeMapEmpty = false;
|
|
auto& it = scratch_iterator;
|
|
it.reset(writes, ver);
|
|
it.skip(key);
|
|
|
|
bool is_cleared = it.entry().following_keys_cleared;
|
|
bool following_conflict = it.entry().following_keys_conflict;
|
|
bool is_conflict = addConflict || it.is_conflict_range();
|
|
bool following_unreadable = it.entry().following_keys_unreadable;
|
|
bool is_unreadable = it.is_unreadable() || operation == MutationRef::SetVersionstampedValue ||
|
|
operation == MutationRef::SetVersionstampedKey;
|
|
bool is_dependent = operation != MutationRef::SetValue && operation != MutationRef::SetVersionstampedValue &&
|
|
operation != MutationRef::SetVersionstampedKey;
|
|
|
|
if (it.entry().key != key) {
|
|
if (it.is_cleared_range() && is_dependent) {
|
|
it.tree.clear();
|
|
OperationStack op(RYWMutation(Optional<StringRef>(), MutationRef::SetValue));
|
|
coalesceOver(op, RYWMutation(param, operation), *arena);
|
|
PTreeImpl::insert(
|
|
writes,
|
|
ver,
|
|
WriteMapEntry(
|
|
key, std::move(op), true, following_conflict, is_conflict, following_unreadable, is_unreadable));
|
|
} else {
|
|
it.tree.clear();
|
|
PTreeImpl::insert(writes,
|
|
ver,
|
|
WriteMapEntry(key,
|
|
OperationStack(RYWMutation(param, operation)),
|
|
is_cleared,
|
|
following_conflict,
|
|
is_conflict,
|
|
following_unreadable,
|
|
is_unreadable));
|
|
}
|
|
} else {
|
|
if (!it.is_unreadable() &&
|
|
(operation == MutationRef::SetValue || operation == MutationRef::SetVersionstampedValue)) {
|
|
it.tree.clear();
|
|
PTreeImpl::remove(writes, ver, key);
|
|
PTreeImpl::insert(writes,
|
|
ver,
|
|
WriteMapEntry(key,
|
|
OperationStack(RYWMutation(param, operation)),
|
|
is_cleared,
|
|
following_conflict,
|
|
is_conflict,
|
|
following_unreadable,
|
|
is_unreadable));
|
|
} else {
|
|
WriteMapEntry e(it.entry());
|
|
e.is_conflict = is_conflict;
|
|
e.is_unreadable = is_unreadable;
|
|
if (e.stack.size() == 0 && it.is_cleared_range() && is_dependent) {
|
|
e.stack.push(RYWMutation(Optional<StringRef>(), MutationRef::SetValue));
|
|
coalesceOver(e.stack, RYWMutation(param, operation), *arena);
|
|
} else if (!is_unreadable && e.stack.size() > 0)
|
|
coalesceOver(e.stack, RYWMutation(param, operation), *arena);
|
|
else
|
|
e.stack.push(RYWMutation(param, operation));
|
|
|
|
it.tree.clear();
|
|
PTreeImpl::remove(
|
|
writes,
|
|
ver,
|
|
e.key); // FIXME: Make PTreeImpl::insert do this automatically (see also VersionedMap.h FIXME)
|
|
PTreeImpl::insert(writes, ver, std::move(e));
|
|
}
|
|
}
|
|
}
|
|
|
|
void WriteMap::clear(KeyRangeRef keys, bool addConflict) {
|
|
writeMapEmpty = false;
|
|
if (!addConflict) {
|
|
clearNoConflict(keys);
|
|
return;
|
|
}
|
|
|
|
auto& it = scratch_iterator;
|
|
it.reset(writes, ver);
|
|
it.skip(keys.begin);
|
|
|
|
bool insert_begin = !it.is_cleared_range() || !it.is_conflict_range() || it.is_unreadable();
|
|
|
|
if (it.endKey() == keys.end) {
|
|
++it;
|
|
} else if (it.endKey() < keys.end) {
|
|
it.skip(keys.end);
|
|
}
|
|
|
|
bool insert_end = (it.is_unmodified_range() || !it.is_conflict_range() || it.is_unreadable()) &&
|
|
(!it.keyAtBegin() || it.beginKey() != keys.end);
|
|
bool end_coalesce_clear =
|
|
it.is_cleared_range() && it.beginKey() == keys.end && it.is_conflict_range() && !it.is_unreadable();
|
|
bool end_conflict = it.is_conflict_range();
|
|
bool end_cleared = it.is_cleared_range();
|
|
bool end_unreadable = it.is_unreadable();
|
|
|
|
it.tree.clear();
|
|
|
|
PTreeImpl::remove(writes,
|
|
ver,
|
|
ExtStringRef(keys.begin, !insert_begin ? 1 : 0),
|
|
ExtStringRef(keys.end, end_coalesce_clear ? 1 : 0));
|
|
|
|
if (insert_begin)
|
|
PTreeImpl::insert(writes, ver, WriteMapEntry(keys.begin, OperationStack(), true, true, true, false, false));
|
|
|
|
if (insert_end)
|
|
PTreeImpl::insert(
|
|
writes,
|
|
ver,
|
|
WriteMapEntry(
|
|
keys.end, OperationStack(), end_cleared, end_conflict, end_conflict, end_unreadable, end_unreadable));
|
|
}
|
|
|
|
void WriteMap::addUnmodifiedAndUnreadableRange(KeyRangeRef keys) {
|
|
auto& it = scratch_iterator;
|
|
it.reset(writes, ver);
|
|
it.skip(keys.begin);
|
|
|
|
bool insert_begin = !it.is_unmodified_range() || it.is_conflict_range() || !it.is_unreadable();
|
|
|
|
if (it.endKey() == keys.end) {
|
|
++it;
|
|
} else if (it.endKey() < keys.end) {
|
|
it.skip(keys.end);
|
|
}
|
|
|
|
bool insert_end = (it.is_cleared_range() || it.is_conflict_range() || !it.is_unreadable()) &&
|
|
(!it.keyAtBegin() || it.beginKey() != keys.end);
|
|
bool end_coalesce_unmodified =
|
|
it.is_unmodified_range() && it.beginKey() == keys.end && !it.is_conflict_range() && it.is_unreadable();
|
|
bool end_conflict = it.is_conflict_range();
|
|
bool end_cleared = it.is_cleared_range();
|
|
bool end_unreadable = it.is_unreadable();
|
|
|
|
it.tree.clear();
|
|
|
|
PTreeImpl::remove(writes,
|
|
ver,
|
|
ExtStringRef(keys.begin, !insert_begin ? 1 : 0),
|
|
ExtStringRef(keys.end, end_coalesce_unmodified ? 1 : 0));
|
|
|
|
if (insert_begin)
|
|
PTreeImpl::insert(writes, ver, WriteMapEntry(keys.begin, OperationStack(), false, false, false, true, true));
|
|
|
|
if (insert_end)
|
|
PTreeImpl::insert(
|
|
writes,
|
|
ver,
|
|
WriteMapEntry(
|
|
keys.end, OperationStack(), end_cleared, end_conflict, end_conflict, end_unreadable, end_unreadable));
|
|
}
|
|
|
|
void WriteMap::addConflictRange(KeyRangeRef keys) {
|
|
writeMapEmpty = false;
|
|
auto& it = scratch_iterator;
|
|
it.reset(writes, ver);
|
|
it.skip(keys.begin);
|
|
|
|
std::vector<ExtStringRef> removals;
|
|
std::vector<WriteMapEntry> insertions;
|
|
|
|
if (!it.entry().following_keys_conflict || !it.entry().is_conflict) {
|
|
if (it.keyAtBegin() && it.beginKey() == keys.begin) {
|
|
removals.push_back(keys.begin);
|
|
}
|
|
insertions.push_back(WriteMapEntry(keys.begin,
|
|
it.is_operation() ? OperationStack(it.op()) : OperationStack(),
|
|
it.entry().following_keys_cleared,
|
|
true,
|
|
true,
|
|
it.entry().following_keys_unreadable,
|
|
it.entry().is_unreadable));
|
|
}
|
|
|
|
while (it.endKey() < keys.end) {
|
|
++it;
|
|
if (it.keyAtBegin() && (!it.entry().following_keys_conflict || !it.entry().is_conflict)) {
|
|
WriteMapEntry e(it.entry());
|
|
e.following_keys_conflict = true;
|
|
e.is_conflict = true;
|
|
removals.push_back(e.key);
|
|
insertions.push_back(std::move(e));
|
|
}
|
|
}
|
|
|
|
ASSERT(it.beginKey() != keys.end);
|
|
if (!it.entry().following_keys_conflict || !it.entry().is_conflict) {
|
|
bool isCleared = it.entry().following_keys_cleared;
|
|
bool isUnreadable = it.entry().is_unreadable;
|
|
bool followingUnreadable = it.entry().following_keys_unreadable;
|
|
++it;
|
|
|
|
if (!it.keyAtBegin() || it.beginKey() != keys.end) {
|
|
insertions.push_back(
|
|
WriteMapEntry(keys.end, OperationStack(), isCleared, false, false, followingUnreadable, isUnreadable));
|
|
}
|
|
}
|
|
|
|
it.tree.clear();
|
|
|
|
// SOMEDAY: optimize this code by having a PTree removal/insertion that takes and returns an iterator
|
|
for (int i = 0; i < removals.size(); i++) {
|
|
PTreeImpl::remove(
|
|
writes,
|
|
ver,
|
|
removals[i]); // FIXME: Make PTreeImpl::insert do this automatically (see also VersionedMap.h FIXME)
|
|
}
|
|
|
|
for (int i = 0; i < insertions.size(); i++) {
|
|
PTreeImpl::insert(writes, ver, std::move(insertions[i]));
|
|
}
|
|
}
|
|
|
|
WriteMap::iterator::SEGMENT_TYPE WriteMap::iterator::type() const {
|
|
if (offset)
|
|
return entry().following_keys_cleared ? CLEARED_RANGE : UNMODIFIED_RANGE;
|
|
else
|
|
return entry().stack.isDependent() ? DEPENDENT_WRITE : INDEPENDENT_WRITE;
|
|
}
|
|
|
|
WriteMap::iterator& WriteMap::iterator::operator++() {
|
|
if (!offset && !equalsKeyAfter(entry().key, nextEntry().key)) {
|
|
offset = true;
|
|
} else {
|
|
beginLen = endLen;
|
|
finger.resize(beginLen);
|
|
endLen = PTreeImpl::halfNext(at, finger);
|
|
offset = !entry().stack.size();
|
|
}
|
|
return *this;
|
|
}
|
|
WriteMap::iterator& WriteMap::iterator::operator--() {
|
|
if (offset && entry().stack.size()) {
|
|
offset = false;
|
|
} else {
|
|
endLen = beginLen;
|
|
finger.resize(endLen);
|
|
beginLen = PTreeImpl::halfPrevious(at, finger);
|
|
offset = !entry().stack.size() || !equalsKeyAfter(entry().key, nextEntry().key);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void WriteMap::iterator::skip(
|
|
KeyRef key) { // Changes *this to the segment containing key (so that beginKey()<=key && key < endKey())
|
|
finger.clear();
|
|
|
|
if (key == allKeys.end)
|
|
PTreeImpl::last(tree, at, finger);
|
|
else
|
|
PTreeImpl::upper_bound(tree, at, key, finger);
|
|
endLen = finger.size();
|
|
beginLen = PTreeImpl::halfPrevious(at, finger);
|
|
|
|
offset = !entry().stack.size() || (entry().key != key);
|
|
}
|
|
|
|
void WriteMap::iterator::reset(Tree const& tree, Version ver) {
|
|
this->tree = tree;
|
|
this->at = ver;
|
|
this->finger.clear();
|
|
beginLen = endLen = 0;
|
|
offset = false;
|
|
}
|
|
|
|
RYWMutation WriteMap::coalesce(RYWMutation existingEntry, RYWMutation newEntry, Arena& arena) {
|
|
ASSERT(newEntry.value.present());
|
|
|
|
if (newEntry.type == MutationRef::SetValue || newEntry.type == MutationRef::SetVersionstampedValue) {
|
|
// independent mutations
|
|
return newEntry;
|
|
} else if (newEntry.type == MutationRef::AddValue) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doLittleEndianAdd(existingEntry.value, newEntry.value.get(), arena),
|
|
MutationRef::SetValue);
|
|
case MutationRef::AddValue:
|
|
return RYWMutation(doLittleEndianAdd(existingEntry.value, newEntry.value.get(), arena),
|
|
MutationRef::AddValue);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::CompareAndClear) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
if (doCompareAndClear(existingEntry.value, newEntry.value.get(), arena).present()) {
|
|
return existingEntry;
|
|
} else {
|
|
return RYWMutation(Optional<ValueRef>(), MutationRef::SetValue);
|
|
}
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::AppendIfFits) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doAppendIfFits(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::AppendIfFits:
|
|
return RYWMutation(doAppendIfFits(existingEntry.value, newEntry.value.get(), arena),
|
|
MutationRef::AppendIfFits);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::And) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doAnd(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::And:
|
|
return RYWMutation(doAnd(existingEntry.value, newEntry.value.get(), arena), MutationRef::And);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::Or) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doOr(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::Or:
|
|
return RYWMutation(doOr(existingEntry.value, newEntry.value.get(), arena), MutationRef::Or);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::Xor) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doXor(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::Xor:
|
|
return RYWMutation(doXor(existingEntry.value, newEntry.value.get(), arena), MutationRef::Xor);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::Max) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doMax(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::Max:
|
|
return RYWMutation(doMax(existingEntry.value, newEntry.value.get(), arena), MutationRef::Max);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::Min) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doMin(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::Min:
|
|
return RYWMutation(doMin(existingEntry.value, newEntry.value.get(), arena), MutationRef::Min);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::ByteMin) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doByteMin(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::ByteMin:
|
|
return RYWMutation(doByteMin(existingEntry.value, newEntry.value.get(), arena), MutationRef::ByteMin);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::ByteMax) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doByteMax(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::ByteMax:
|
|
return RYWMutation(doByteMax(existingEntry.value, newEntry.value.get(), arena), MutationRef::ByteMax);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::MinV2) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doMinV2(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::MinV2:
|
|
return RYWMutation(doMinV2(existingEntry.value, newEntry.value.get(), arena), MutationRef::MinV2);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else if (newEntry.type == MutationRef::AndV2) {
|
|
switch (existingEntry.type) {
|
|
case MutationRef::SetValue:
|
|
return RYWMutation(doAndV2(existingEntry.value, newEntry.value.get(), arena), MutationRef::SetValue);
|
|
case MutationRef::AndV2:
|
|
return RYWMutation(doAndV2(existingEntry.value, newEntry.value.get(), arena), MutationRef::AndV2);
|
|
default:
|
|
throw operation_failed();
|
|
}
|
|
} else
|
|
throw operation_failed();
|
|
}
|
|
|
|
void WriteMap::coalesceOver(OperationStack& stack, RYWMutation newEntry, Arena& arena) {
|
|
RYWMutation existingEntry = stack.top();
|
|
if (existingEntry.type == newEntry.type && newEntry.type != MutationRef::CompareAndClear) {
|
|
if (isNonAssociativeOp(existingEntry.type) && existingEntry.value.present() &&
|
|
existingEntry.value.get().size() != newEntry.value.get().size()) {
|
|
stack.push(newEntry);
|
|
} else {
|
|
stack.poppush(coalesce(existingEntry, newEntry, arena));
|
|
}
|
|
} else {
|
|
if (isAtomicOp(newEntry.type) && isAtomicOp(existingEntry.type)) {
|
|
stack.push(newEntry);
|
|
} else {
|
|
stack.poppush(coalesce(existingEntry, newEntry, arena));
|
|
}
|
|
}
|
|
}
|
|
|
|
RYWMutation WriteMap::coalesceUnder(OperationStack const& stack, Optional<ValueRef> const& value, Arena& arena) {
|
|
if (!stack.isDependent() && stack.size() == 1)
|
|
return stack.at(0);
|
|
|
|
RYWMutation currentEntry = RYWMutation(value, MutationRef::SetValue);
|
|
for (int i = 0; i < stack.size(); ++i) {
|
|
currentEntry = coalesce(currentEntry, stack.at(i), arena);
|
|
}
|
|
|
|
return currentEntry;
|
|
}
|
|
|
|
void WriteMap::dump() {
|
|
iterator it(this);
|
|
it.skip(allKeys.begin);
|
|
while (it.beginKey() < allKeys.end) {
|
|
TraceEvent("WriteMapDump")
|
|
.detail("Begin", it.beginKey().toStandaloneStringRef())
|
|
.detail("End", it.endKey())
|
|
.detail("Cleared", it.is_cleared_range())
|
|
.detail("Conflicted", it.is_conflict_range())
|
|
.detail("Operation", it.is_operation())
|
|
.detail("Unmodified", it.is_unmodified_range())
|
|
.detail("Independent", it.is_operation() && it.is_independent())
|
|
.detail("StackSize", it.is_operation() ? it.op().size() : 0);
|
|
++it;
|
|
}
|
|
}
|
|
|
|
void WriteMap::clearNoConflict(KeyRangeRef keys) {
|
|
auto& it = scratch_iterator;
|
|
it.reset(writes, ver);
|
|
|
|
// Find all write conflict ranges within the cleared range
|
|
it.skip(keys.begin);
|
|
|
|
bool insert_begin = !it.is_cleared_range() || it.is_unreadable();
|
|
|
|
bool lastConflicted = it.is_conflict_range();
|
|
|
|
bool conflicted = lastConflicted;
|
|
std::vector<ExtStringRef> conflict_ranges;
|
|
|
|
if (insert_begin) {
|
|
conflict_ranges.push_back(keys.begin);
|
|
} else {
|
|
conflicted = !conflicted;
|
|
}
|
|
|
|
while (it.endKey() < keys.end) {
|
|
++it;
|
|
if (lastConflicted != it.is_conflict_range()) {
|
|
conflict_ranges.push_back(it.beginKey());
|
|
lastConflicted = it.is_conflict_range();
|
|
}
|
|
}
|
|
|
|
if (it.endKey() == keys.end)
|
|
++it;
|
|
|
|
ASSERT(it.beginKey() <= keys.end && keys.end < it.endKey());
|
|
|
|
bool insert_end =
|
|
((it.is_unmodified_range() || it.is_unreadable()) && (!it.keyAtBegin() || it.beginKey() != keys.end)) ||
|
|
(it.entry().is_conflict && !it.entry().following_keys_conflict && it.beginKey() == keys.end &&
|
|
!it.keyAtBegin());
|
|
bool end_cleared = it.is_cleared_range();
|
|
bool end_coalesce_clear = it.is_cleared_range() && it.beginKey() == keys.end &&
|
|
it.is_conflict_range() == lastConflicted && !it.is_unreadable();
|
|
bool end_conflict = it.is_conflict_range();
|
|
bool end_unreadable = it.is_unreadable();
|
|
|
|
CODE_PROBE(it.is_conflict_range() != lastConflicted, "not last conflicted");
|
|
|
|
it.tree.clear();
|
|
|
|
PTreeImpl::remove(writes,
|
|
ver,
|
|
ExtStringRef(keys.begin, !insert_begin ? 1 : 0),
|
|
ExtStringRef(keys.end, end_coalesce_clear ? 1 : 0));
|
|
|
|
for (int i = 0; i < conflict_ranges.size(); i++) {
|
|
PTreeImpl::insert(
|
|
writes,
|
|
ver,
|
|
WriteMapEntry(
|
|
conflict_ranges[i].toArenaOrRef(*arena), OperationStack(), true, conflicted, conflicted, false, false));
|
|
conflicted = !conflicted;
|
|
}
|
|
|
|
ASSERT(conflicted != lastConflicted);
|
|
|
|
if (insert_end)
|
|
PTreeImpl::insert(
|
|
writes,
|
|
ver,
|
|
WriteMapEntry(
|
|
keys.end, OperationStack(), end_cleared, end_conflict, end_conflict, end_unreadable, end_unreadable));
|
|
}
|