return handle_split(
c, ret
).si_then([c, laddr, val, &ret] {
- if (!ret.leaf.node->is_pending()) {
+ if (!ret.leaf.node->is_mutable()) {
CachedExtentRef mut = c.cache.duplicate_for_write(
c.trans, ret.leaf.node
);
"update element at {}",
c.trans,
iter.is_end() ? min_max_t<node_key_t>::max : iter.get_key());
- if (!iter.leaf.node->is_pending()) {
+ if (!iter.leaf.node->is_mutable()) {
CachedExtentRef mut = c.cache.duplicate_for_write(
c.trans, iter.leaf.node
);
return seastar::do_with(
iter,
[this, c](auto &ret) {
- if (!ret.leaf.node->is_pending()) {
+ if (!ret.leaf.node->is_mutable()) {
CachedExtentRef mut = c.cache.duplicate_for_write(
c.trans, ret.leaf.node
);
for (; split_from > 0; --split_from) {
auto &parent_pos = iter.get_internal(split_from + 1);
- if (!parent_pos.node->is_pending()) {
+ if (!parent_pos.node->is_mutable()) {
parent_pos.node = c.cache.duplicate_for_write(
c.trans, parent_pos.node
)->template cast<internal_node_t>();
node_position_t<NodeType> &pos)
{
LOG_PREFIX(FixedKVBtree::merge_level);
- if (!parent_pos.node->is_pending()) {
+ if (!parent_pos.node->is_mutable()) {
parent_pos.node = c.cache.duplicate_for_write(
c.trans, parent_pos.node
)->template cast<internal_node_t>();
/**
* Internal relative addresses on read or in memory prior to commit
* are either record or block relative depending on whether this
- * physical node is is_initial_pending() or just is_pending().
+ * physical node is is_initial_pending() or just is_mutable().
*
* User passes appropriate base depending on lifecycle and
* resolve_relative_addrs fixes up relative internal references
return TCachedExtentRef<const T>(static_cast<const T*>(this));
}
+ /// Returns true if extent can be mutated in an open transaction
bool is_mutable() const {
return state == extent_state_t::INITIAL_WRITE_PENDING ||
state == extent_state_t::MUTATION_PENDING ||
/// number of deltas since initial write
extent_version_t version = 0;
- /// address of original block -- relative iff is_pending() and is_clean()
+ /// address of original block -- record relative iff is_initial_pending()
paddr_t poffset;
/// relative address before ool write, used to update mapping
{
read_to_local();
logger().debug("CollectionNode:{}", __func__);
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = cc.tm.get_mutable_extent(cc.t, this)->cast<CollectionNode>();
return mut->create(cc, coll, bits);
}
{
read_to_local();
logger().debug("CollectionNode:{}", __func__);
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = cc.tm.get_mutable_extent(cc.t, this)->cast<CollectionNode>();
return mut->update(cc, coll, bits);
}
{
read_to_local();
logger().debug("CollectionNode:{}", __func__);
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = cc.tm.get_mutable_extent(cc.t, this)->cast<CollectionNode>();
return mut->remove(cc, coll);
}
{
LOG_PREFIX(OMapInnerNode::handle_split);
DEBUGT("this: {}", oc.t, *this);
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = oc.tm.get_mutable_extent(oc.t, this)->cast<OMapInnerNode>();
auto mut_iter = mut->iter_idx(iter.get_index());
return mut->handle_split(oc, mut_iter, mresult);
{
LOG_PREFIX(OMapInnerNode::merge_entry);
DEBUGT("{}, parent: {}", oc.t, *entry, *this);
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = oc.tm.get_mutable_extent(oc.t, this)->cast<OMapInnerNode>();
auto mut_iter = mut->iter_idx(iter->get_index());
return mut->merge_entry(oc, mut_iter, entry);
DEBUGT("{} -> {}, this: {}", oc.t, key, value, *this);
bool overflow = extent_will_overflow(key.size(), value.length());
if (!overflow) {
- if (!is_pending()) {
+ if (!is_mutable()) {
auto mut = oc.tm.get_mutable_extent(oc.t, this)->cast<OMapLeafNode>();
return mut->insert(oc, key, value);
}
LOG_PREFIX(OMapLeafNode::rm_key);
DEBUGT("{}, this: {}", oc.t, key, *this);
auto rm_pt = find_string_key(key);
- if (!is_pending() && rm_pt != iter_end()) {
+ if (!is_mutable() && rm_pt != iter_end()) {
auto mut = oc.tm.get_mutable_extent(oc.t, this)->cast<OMapLeafNode>();
return mut->rm_key(oc, key);
}
assert(p_recorder->node_type() == NODE_TYPE);
assert(p_recorder->field_type() == FIELD_TYPE);
recorder = static_cast<recorder_t*>(p_recorder);
- } else if (!extent->is_pending() && extent->is_valid()) {
+ } else if (!extent->is_mutable() && extent->is_valid()) {
state = nextent_state_t::READ_ONLY;
// mut is empty
assert(extent->get_recorder() == nullptr ||
void prepare_mutate(context_t c) {
assert(!is_retired());
if (state == nextent_state_t::READ_ONLY) {
- assert(!extent->is_pending());
+ assert(!extent->is_mutable());
auto ref_recorder = recorder_t::create_for_encode(c.vb);
recorder = static_cast<recorder_t*>(ref_recorder.get());
extent = extent->mutate(c, std::move(ref_recorder));
assert(recorder == static_cast<recorder_t*>(extent->get_recorder()));
mut.emplace(extent->get_mutable());
}
- assert(extent->is_pending());
+ assert(extent->is_mutable());
}
template <KeyT KT>
position_t& insert_pos,
match_stage_t& insert_stage,
node_offset_t& insert_size) {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->template encode_insert<KT>(
}
void split_replayable(StagedIterator& split_at) {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->encode_split(split_at, read().p_start());
position_t& insert_pos,
match_stage_t& insert_stage,
node_offset_t& insert_size) {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->template encode_split_insert<KT>(
void update_child_addr_replayable(
const laddr_t new_addr, laddr_packed_t* p_addr) {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->encode_update_child_addr(
}
std::tuple<match_stage_t, position_t> erase_replayable(const position_t& pos) {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->encode_erase(pos);
}
position_t make_tail_replayable() {
- assert(extent->is_pending());
+ assert(extent->is_mutable());
assert(state != nextent_state_t::READ_ONLY);
if (state == nextent_state_t::MUTATION_PENDING) {
recorder->encode_make_tail();
return get_bptr().c_str();
}
NodeExtentMutable get_mutable() {
- assert(is_pending());
+ assert(is_mutable());
return do_get_mutable();
}
"extent is already duplicated -- {}",
t,
*ref);
- assert(ref->is_pending());
+ assert(ref->is_mutable());
assert(&*ref == &*ret);
}
return ret;