{
return crimson::do_for_each(
onodes,
- [this, &trans](auto &onode) -> OnodeTree::btree_future<> {
+ [this, &trans](auto &onode) -> eagain_future<> {
auto &flonode = static_cast<FLTreeOnode&>(*onode);
switch (flonode.status) {
case FLTreeOnode::status_t::MUTATED: {
std::move(cursor),
list_onodes_bare_ret(),
[this, &trans, end] (auto& to_list, auto& current_cursor, auto& ret) {
- using get_next_ertr = typename OnodeTree::btree_ertr;
return crimson::do_until(
[this, &trans, end, &to_list, ¤t_cursor, &ret] () mutable
- -> get_next_ertr::future<bool> {
+ -> eagain_future<bool> {
if (current_cursor.is_end() ||
current_cursor.get_ghobj() >= end) {
std::get<1>(ret) = end;
using eagain_ertr = crimson::errorator<
crimson::ct_error::eagain>;
+template <class ValueT=void>
+using eagain_future = eagain_ertr::future<ValueT>;
using crimson::os::seastore::Transaction;
using crimson::os::seastore::TransactionRef;
#include "stages/node_stage_layout.h"
namespace crimson::os::seastore::onode {
-
-using node_ertr = Node::node_ertr;
-template <class ValueT=void>
-using node_future = Node::node_future<ValueT>;
-
/*
* tree_cursor_t
*/
}
}
-tree_cursor_t::future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
tree_cursor_t::get_next(context_t c)
{
assert(is_tracked());
}
template <bool FORCE_MERGE>
-tree_cursor_t::future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
tree_cursor_t::erase(context_t c, bool get_next)
{
assert(is_tracked());
return ref_leaf_node->erase<FORCE_MERGE>(c, position, get_next);
}
-template tree_cursor_t::future<Ref<tree_cursor_t>>
+template eagain_future<Ref<tree_cursor_t>>
tree_cursor_t::erase<true>(context_t, bool);
-template tree_cursor_t::future<Ref<tree_cursor_t>>
+template eagain_future<Ref<tree_cursor_t>>
tree_cursor_t::erase<false>(context_t, bool);
MatchKindCMP tree_cursor_t::compare_to(
return ret;
}
-tree_cursor_t::future<>
+eagain_future<>
tree_cursor_t::extend_value(context_t c, value_size_t extend_size)
{
assert(is_tracked());
return ref_leaf_node->extend_value(c, position, extend_size);
}
-tree_cursor_t::future<>
+eagain_future<>
tree_cursor_t::trim_value(context_t c, value_size_t trim_size)
{
assert(is_tracked());
return impl->level();
}
-node_future<Node::search_result_t> Node::lower_bound(
+eagain_future<Node::search_result_t> Node::lower_bound(
context_t c, const key_hobj_t& key)
{
return seastar::do_with(
);
}
-node_future<std::pair<Ref<tree_cursor_t>, bool>> Node::insert(
+eagain_future<std::pair<Ref<tree_cursor_t>, bool>> Node::insert(
context_t c, const key_hobj_t& key, value_config_t vconf)
{
return seastar::do_with(
return lower_bound_tracked(c, key, history
).safe_then([c, &key, vconf, &history](auto result) {
if (result.match() == MatchKindBS::EQ) {
- return node_ertr::make_ready_future<std::pair<Ref<tree_cursor_t>, bool>>(
+ return eagain_ertr::make_ready_future<std::pair<Ref<tree_cursor_t>, bool>>(
std::make_pair(result.p_cursor, false));
} else {
auto leaf_node = result.p_cursor->get_leaf_node();
return leaf_node->insert_value(
c, key, vconf, result.p_cursor->get_position(), history, result.mstat
).safe_then([](auto p_cursor) {
- return node_ertr::make_ready_future<std::pair<Ref<tree_cursor_t>, bool>>(
+ return seastar::make_ready_future<std::pair<Ref<tree_cursor_t>, bool>>(
std::make_pair(p_cursor, true));
});
}
);
}
-node_future<std::size_t> Node::erase(
+eagain_future<std::size_t> Node::erase(
context_t c, const key_hobj_t& key)
{
return lower_bound(c, key).safe_then([c] (auto result) {
if (result.match() != MatchKindBS::EQ) {
- return node_ertr::make_ready_future<std::size_t>(0);
+ return eagain_ertr::make_ready_future<std::size_t>(0);
}
auto ref_cursor = result.p_cursor;
return ref_cursor->erase(c, false
});
}
-node_future<tree_stats_t> Node::get_tree_stats(context_t c)
+eagain_future<tree_stats_t> Node::get_tree_stats(context_t c)
{
return seastar::do_with(
tree_stats_t(), [this, c](auto& stats) {
make_root(c, std::move(_super));
}
-node_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker)
+eagain_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker)
{
LOG_PREFIX(OTree::Node::mkfs);
return LeafNode::allocate_root(c, root_tracker
});
}
-node_future<Ref<Node>> Node::load_root(context_t c, RootNodeTracker& root_tracker)
+eagain_future<Ref<Node>> Node::load_root(context_t c, RootNodeTracker& root_tracker)
{
LOG_PREFIX(OTree::Node::load_root);
return c.nm.get_super(c.t, root_tracker
std::ignore = c; // as only used in an assert
std::ignore = root_tracker;
assert(root == root_tracker.get_root(c.t));
- return node_ertr::make_ready_future<Ref<Node>>(root);
+ return seastar::make_ready_future<Ref<Node>>(root);
});
});
}
super->do_track_root(*this);
}
-node_future<> Node::upgrade_root(context_t c)
+eagain_future<> Node::upgrade_root(context_t c)
{
LOG_PREFIX(OTree::Node::upgrade_root);
assert(is_root());
template void Node::as_child<true>(const search_position_t&, Ref<InternalNode>);
template void Node::as_child<false>(const search_position_t&, Ref<InternalNode>);
-node_future<> Node::apply_split_to_parent(
+eagain_future<> Node::apply_split_to_parent(
context_t c,
Ref<Node>&& this_ref,
Ref<Node>&& split_right,
c, std::move(this_ref), std::move(split_right), update_right_index);
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
Node::get_next_cursor_from_parent(context_t c)
{
assert(!impl->is_level_tail());
}
template <bool FORCE_MERGE>
-node_future<>
+eagain_future<>
Node::try_merge_adjacent(
context_t c, bool update_parent_index, Ref<Node>&& this_ref)
{
return fix_parent_index(c, std::move(this_ref), false);
} else {
parent_info().ptr->validate_child_tracked(*this);
- return node_ertr::now();
+ return eagain_ertr::now();
}
}
}
return parent_info().ptr->get_child_peers(c, parent_info().position
).safe_then([c, this_ref = std::move(this_ref), this, FNAME,
- update_parent_index] (auto lr_nodes) mutable -> node_future<> {
+ update_parent_index] (auto lr_nodes) mutable -> eagain_future<> {
auto& [lnode, rnode] = lr_nodes;
Ref<Node> left_for_merge;
Ref<Node> right_for_merge;
return fix_parent_index(c, std::move(*p_this_ref), false);
} else {
parent_info().ptr->validate_child_tracked(*this);
- return node_ertr::now();
+ return eagain_ertr::now();
}
// XXX: rebalance
});
}
-template node_future<> Node::try_merge_adjacent<true>(context_t, bool, Ref<Node>&&);
-template node_future<> Node::try_merge_adjacent<false>(context_t, bool, Ref<Node>&&);
+template eagain_future<> Node::try_merge_adjacent<true>(context_t, bool, Ref<Node>&&);
+template eagain_future<> Node::try_merge_adjacent<false>(context_t, bool, Ref<Node>&&);
-node_future<> Node::erase_node(context_t c, Ref<Node>&& this_ref)
+eagain_future<> Node::erase_node(context_t c, Ref<Node>&& this_ref)
{
assert(this_ref.get() == this);
assert(!is_tracking());
}
template <bool FORCE_MERGE>
-node_future<> Node::fix_parent_index(
+eagain_future<> Node::fix_parent_index(
context_t c, Ref<Node>&& this_ref, bool check_downgrade)
{
assert(!is_root());
parent->validate_tracked_children();
return parent->fix_index<FORCE_MERGE>(c, std::move(this_ref), check_downgrade);
}
-template node_future<> Node::fix_parent_index<true>(context_t, Ref<Node>&&, bool);
-template node_future<> Node::fix_parent_index<false>(context_t, Ref<Node>&&, bool);
+template eagain_future<> Node::fix_parent_index<true>(context_t, Ref<Node>&&, bool);
+template eagain_future<> Node::fix_parent_index<false>(context_t, Ref<Node>&&, bool);
-node_future<Ref<Node>> Node::load(
+eagain_future<Ref<Node>> Node::load(
context_t c, laddr_t addr, bool expect_is_level_tail)
{
LOG_PREFIX(OTree::Node::load);
});
}
-node_future<NodeExtentMutable> Node::rebuild_extent(context_t c)
+eagain_future<NodeExtentMutable> Node::rebuild_extent(context_t c)
{
LOG_PREFIX(OTree::Node::rebuild_extent);
DEBUGT("{} ...", c.t, get_name());
return impl->rebuild_extent(c);
}
-node_future<> Node::retire(context_t c, Ref<Node>&& this_ref)
+eagain_future<> Node::retire(context_t c, Ref<Node>&& this_ref)
{
LOG_PREFIX(OTree::Node::retire);
DEBUGT("{} ...", c.t, get_name());
InternalNode::InternalNode(InternalNodeImpl* impl, NodeImplURef&& impl_ref)
: Node(std::move(impl_ref)), impl{impl} {}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
InternalNode::get_next_cursor(context_t c, const search_position_t& pos)
{
impl->validate_non_empty();
}
}
-node_future<> InternalNode::apply_child_split(
+eagain_future<> InternalNode::apply_child_split(
context_t c, Ref<Node>&& left_child, Ref<Node>&& right_child,
bool update_right_index)
{
return apply_split_to_parent(
c, std::move(this_ref), std::move(split_right), false);
} else {
- return node_ertr::now();
+ return eagain_ertr::now();
}
}).safe_then([c, update_right_index,
right_child = std::move(right_child)] () mutable {
// there is no need to call try_merge_adjacent() because
// the filled size of the inserted node or the split right node
// won't be reduced if update_right_index is false.
- return node_ertr::now();
+ return eagain_ertr::now();
}
});
}
-node_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
+eagain_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
{
LOG_PREFIX(OTree::InternalNode::erase_child);
// this is a special version of recursive merge
// and trigger prv_child_ref->try_merge_adjacent() at the end
bool fix_tail = (child_ref->parent_info().position.is_end() &&
!impl->is_keys_empty());
- return node_ertr::now().safe_then([c, this, fix_tail] {
+ return seastar::now().then([c, this, fix_tail] {
if (fix_tail) {
search_position_t new_tail_pos;
const laddr_packed_t* new_tail_p_addr = nullptr;
impl->get_largest_slot(&new_tail_pos, nullptr, &new_tail_p_addr);
return get_or_track_child(c, new_tail_pos, new_tail_p_addr->value);
} else {
- return node_ertr::make_ready_future<Ref<Node>>();
+ return eagain_ertr::make_ready_future<Ref<Node>>();
}
}).safe_then([c, this, child_ref = std::move(child_ref), FNAME]
(auto&& new_tail_child) mutable {
return new_tail_child->try_merge_adjacent(
c, false, std::move(new_tail_child));
} else {
- return node_ertr::now();
+ return eagain_ertr::now();
}
});
});
}
template <bool FORCE_MERGE>
-node_future<> InternalNode::fix_index(
+eagain_future<> InternalNode::fix_index(
context_t c, Ref<Node>&& child, bool check_downgrade)
{
LOG_PREFIX(OTree::InternalNode::fix_index);
// no need to call try_downgrade_root() because the number of keys
// has not changed, and I must have at least 2 keys.
assert(!impl->is_keys_empty());
- return node_ertr::now();
+ return eagain_ertr::now();
}
} else {
// for non-root, maybe need merge adjacent or fix parent,
}
template <bool FORCE_MERGE>
-node_future<> InternalNode::apply_children_merge(
+eagain_future<> InternalNode::apply_children_merge(
context_t c, Ref<Node>&& left_child, laddr_t origin_left_addr,
Ref<Node>&& right_child, bool update_index)
{
}
});
}
-template node_future<> InternalNode::apply_children_merge<true>(
+template eagain_future<> InternalNode::apply_children_merge<true>(
context_t, Ref<Node>&&, laddr_t, Ref<Node>&&, bool);
-template node_future<> InternalNode::apply_children_merge<false>(
+template eagain_future<> InternalNode::apply_children_merge<false>(
context_t, Ref<Node>&&, laddr_t, Ref<Node>&&, bool);
-node_future<std::pair<Ref<Node>, Ref<Node>>> InternalNode::get_child_peers(
+eagain_future<std::pair<Ref<Node>, Ref<Node>>> InternalNode::get_child_peers(
context_t c, const search_position_t& pos)
{
// assume I'm already ref counted by caller
}
}
- return node_ertr::now().safe_then([this, c, prev_pos, prev_p_child_addr] {
+ return seastar::now().then([this, c, prev_pos, prev_p_child_addr] {
if (prev_p_child_addr != nullptr) {
return get_or_track_child(c, prev_pos, prev_p_child_addr->value);
} else {
- return node_ertr::make_ready_future<Ref<Node>>();
+ return eagain_ertr::make_ready_future<Ref<Node>>();
}
}).safe_then([this, c, next_pos, next_p_child_addr] (Ref<Node> lnode) {
if (next_p_child_addr != nullptr) {
return get_or_track_child(c, next_pos, next_p_child_addr->value
).safe_then([lnode] (Ref<Node> rnode) {
- return node_ertr::make_ready_future<std::pair<Ref<Node>, Ref<Node>>>(
+ return seastar::make_ready_future<std::pair<Ref<Node>, Ref<Node>>>(
lnode, rnode);
});
} else {
- return node_ertr::make_ready_future<std::pair<Ref<Node>, Ref<Node>>>(
+ return eagain_ertr::make_ready_future<std::pair<Ref<Node>, Ref<Node>>>(
lnode, nullptr);
}
});
}
-node_future<Ref<InternalNode>> InternalNode::allocate_root(
+eagain_future<Ref<InternalNode>> InternalNode::allocate_root(
context_t c, level_t old_root_level,
laddr_t old_root_addr, Super::URef&& super)
{
});
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
InternalNode::lookup_smallest(context_t c)
{
impl->validate_non_empty();
});
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
InternalNode::lookup_largest(context_t c)
{
// NOTE: unlike LeafNode::lookup_largest(), this only works for the tail
});
}
-node_future<Node::search_result_t>
+eagain_future<Node::search_result_t>
InternalNode::lower_bound_tracked(
context_t c, const key_hobj_t& key, MatchHistory& history)
{
});
}
-node_future<> InternalNode::do_get_tree_stats(
+eagain_future<> InternalNode::do_get_tree_stats(
context_t c, tree_stats_t& stats)
{
impl->validate_non_empty();
pos = search_position_t::begin();
impl->get_slot(pos, nullptr, &p_child_addr);
return crimson::do_until(
- [this, this_ref, c, &stats, &pos, &p_child_addr]() -> node_future<bool> {
+ [this, this_ref, c, &stats, &pos, &p_child_addr]() -> eagain_future<bool> {
return get_or_track_child(c, pos, p_child_addr->value
).safe_then([c, &stats](auto child) {
return child->do_get_tree_stats(c, stats);
}).safe_then([this, this_ref, &pos, &p_child_addr] {
if (pos.is_end()) {
- return node_ertr::make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
} else {
impl->get_next_slot(pos, nullptr, &p_child_addr);
if (pos.is_end()) {
if (impl->is_level_tail()) {
p_child_addr = impl->get_tail_value();
- return node_ertr::make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
} else {
- return node_ertr::make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
} else {
- return node_ertr::make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
}
}
});
validate_tracked_children();
}
-node_future<> InternalNode::test_clone_root(
+eagain_future<> InternalNode::test_clone_root(
context_t c_other, RootNodeTracker& tracker_other) const
{
assert(is_root());
});
}
-node_future<> InternalNode::try_downgrade_root(
+eagain_future<> InternalNode::try_downgrade_root(
context_t c, Ref<Node>&& this_ref)
{
LOG_PREFIX(OTree::InternalNode::try_downgrade_root);
assert(impl->is_level_tail());
if (!impl->is_keys_empty()) {
// I have more than 1 values, no need to downgrade
- return node_ertr::now();
+ return eagain_ertr::now();
}
// proceed downgrade root to the only child
});
}
-node_future<Ref<InternalNode>> InternalNode::insert_or_split(
+eagain_future<Ref<InternalNode>> InternalNode::insert_or_split(
context_t c,
const search_position_t& pos,
const key_view_t& insert_key,
}
validate_tracked_children();
- return node_ertr::make_ready_future<Ref<InternalNode>>(nullptr);
+ return eagain_ertr::make_ready_future<Ref<InternalNode>>(nullptr);
}
// proceed to split with insert
// assume I'm already ref-counted by caller
- return (is_root() ? upgrade_root(c) : node_ertr::now()
+ return (is_root() ? upgrade_root(c) : eagain_ertr::now()
).safe_then([this, c] {
return InternalNode::allocate(
c, impl->field_type(), impl->is_level_tail(), impl->level());
});
}
-node_future<Ref<Node>> InternalNode::get_or_track_child(
+eagain_future<Ref<Node>> InternalNode::get_or_track_child(
context_t c, const search_position_t& position, laddr_t child_addr)
{
LOG_PREFIX(OTree::InternalNode::get_or_track_child);
}))
: (TRACET("loaded child tracked {} at pos({})",
c.t, found->second->get_name(), position),
- node_ertr::make_ready_future<Ref<Node>>(found->second))
+ eagain_ertr::make_ready_future<Ref<Node>>(found->second))
).safe_then([this_ref, this, position, child_addr] (auto child) {
assert(child_addr == child->impl->laddr());
assert(position == child->parent_info().position);
#endif
}
-node_future<InternalNode::fresh_node_t> InternalNode::allocate(
+eagain_future<InternalNode::fresh_node_t> InternalNode::allocate(
context_t c, field_type_t field_type, bool is_level_tail, level_t level)
{
return InternalNodeImpl::allocate(c, field_type, is_level_tail, level
return {key_view, p_value_header};
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
LeafNode::get_next_cursor(context_t c, const search_position_t& pos)
{
impl->validate_non_empty();
impl->get_next_slot(next_pos, &index_key, &p_value_header);
if (next_pos.is_end()) {
if (unlikely(is_level_tail())) {
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return eagain_ertr::make_ready_future<Ref<tree_cursor_t>>(
tree_cursor_t::create_end(this));
} else {
return get_next_cursor_from_parent(c);
}
} else {
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return eagain_ertr::make_ready_future<Ref<tree_cursor_t>>(
get_or_track_cursor(next_pos, index_key, p_value_header));
}
}
template <bool FORCE_MERGE>
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
{
LOG_PREFIX(OTree::LeafNode::erase);
c.t, get_name(), pos, get_next);
// get the next cursor
- return node_ertr::now().safe_then([c, &pos, get_next, this] {
+ return seastar::now().then([c, &pos, get_next, this] {
if (get_next) {
return get_next_cursor(c, pos);
} else {
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>();
+ return eagain_ertr::make_ready_future<Ref<tree_cursor_t>>();
}
}).safe_then([c, &pos, this_ref = std::move(this_ref),
this, FNAME] (Ref<tree_cursor_t> next_cursor) {
// reset the node reference from the end cursor
next_cursor.reset();
}
- return node_ertr::now(
- ).safe_then([c, &pos, this_ref = std::move(this_ref),
- this, FNAME] () mutable {
+ return seastar::now().then(
+ [c, &pos, this_ref = std::move(this_ref), this, FNAME] () mutable {
#ifndef NDEBUG
assert(!impl->is_keys_empty());
if (impl->is_keys_one()) {
validate_tracked_cursors();
if (is_root()) {
- return node_ertr::now();
+ return eagain_ertr::now();
} else {
bool update_parent_index;
if (impl->is_level_tail()) {
});
});
}
-template node_future<Ref<tree_cursor_t>>
+template eagain_future<Ref<tree_cursor_t>>
LeafNode::erase<true>(context_t, const search_position_t&, bool);
-template node_future<Ref<tree_cursor_t>>
+template eagain_future<Ref<tree_cursor_t>>
LeafNode::erase<false>(context_t, const search_position_t&, bool);
-node_future<> LeafNode::extend_value(
+eagain_future<> LeafNode::extend_value(
context_t c, const search_position_t& pos, value_size_t extend_size)
{
ceph_abort("not implemented");
- return node_ertr::now();
+ return seastar::now();
}
-node_future<> LeafNode::trim_value(
+eagain_future<> LeafNode::trim_value(
context_t c, const search_position_t& pos, value_size_t trim_size)
{
ceph_abort("not implemented");
- return node_ertr::now();
+ return seastar::now();
}
std::pair<NodeExtentMutable&, ValueDeltaRecorder*>
return impl->prepare_mutate_value_payload(c);
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
LeafNode::lookup_smallest(context_t)
{
if (unlikely(impl->is_keys_empty())) {
assert(is_root());
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return seastar::make_ready_future<Ref<tree_cursor_t>>(
tree_cursor_t::create_end(this));
}
auto pos = search_position_t::begin();
key_view_t index_key;
const value_header_t* p_value_header;
impl->get_slot(pos, &index_key, &p_value_header);
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return seastar::make_ready_future<Ref<tree_cursor_t>>(
get_or_track_cursor(pos, index_key, p_value_header));
}
-node_future<Ref<tree_cursor_t>>
+eagain_future<Ref<tree_cursor_t>>
LeafNode::lookup_largest(context_t)
{
if (unlikely(impl->is_keys_empty())) {
assert(is_root());
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return seastar::make_ready_future<Ref<tree_cursor_t>>(
tree_cursor_t::create_end(this));
}
search_position_t pos;
key_view_t index_key;
const value_header_t* p_value_header = nullptr;
impl->get_largest_slot(&pos, &index_key, &p_value_header);
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(
+ return seastar::make_ready_future<Ref<tree_cursor_t>>(
get_or_track_cursor(pos, index_key, p_value_header));
}
-node_future<Node::search_result_t>
+eagain_future<Node::search_result_t>
LeafNode::lower_bound_tracked(
context_t c, const key_hobj_t& key, MatchHistory& history)
{
}
search_result_t ret{cursor, result.mstat};
ret.validate_input_key(key, c.vb.get_header_magic());
- return node_ertr::make_ready_future<search_result_t>(ret);
+ return seastar::make_ready_future<search_result_t>(ret);
}
-node_future<> LeafNode::do_get_tree_stats(context_t, tree_stats_t& stats)
+eagain_future<> LeafNode::do_get_tree_stats(context_t, tree_stats_t& stats)
{
auto nstats = impl->get_stats();
stats.size_persistent_leaf += nstats.size_persistent;
stats.size_value_leaf += nstats.size_value;
stats.num_kvs_leaf += nstats.num_kvs;
stats.num_nodes_leaf += 1;
- return node_ertr::now();
+ return seastar::now();
}
void LeafNode::track_merge(
validate_tracked_cursors();
}
-node_future<> LeafNode::test_clone_root(
+eagain_future<> LeafNode::test_clone_root(
context_t c_other, RootNodeTracker& tracker_other) const
{
assert(is_root());
}).safe_then([this_ref]{});
}
-node_future<Ref<tree_cursor_t>> LeafNode::insert_value(
+eagain_future<Ref<tree_cursor_t>> LeafNode::insert_value(
context_t c, const key_hobj_t& key, value_config_t vconf,
const search_position_t& pos, const MatchHistory& history,
match_stat_t mstat)
assert(p_value_header->payload_size == vconf.payload_size);
auto ret = track_insert(insert_pos, insert_stage, p_value_header);
validate_tracked_cursors();
- return node_ertr::make_ready_future<Ref<tree_cursor_t>>(ret);
+ return eagain_ertr::make_ready_future<Ref<tree_cursor_t>>(ret);
}
// split and insert
Ref<Node> this_ref = this;
- return (is_root() ? upgrade_root(c) : node_ertr::now()
+ return (is_root() ? upgrade_root(c) : eagain_ertr::now()
).safe_then([this, c] {
return LeafNode::allocate(c, impl->field_type(), impl->is_level_tail());
}).safe_then([this_ref = std::move(this_ref), this, c, &key, vconf, FNAME,
});
}
-node_future<Ref<LeafNode>> LeafNode::allocate_root(
+eagain_future<Ref<LeafNode>> LeafNode::allocate_root(
context_t c, RootNodeTracker& root_tracker)
{
LOG_PREFIX(OTree::LeafNode::allocate_root);
}
}
-node_future<LeafNode::fresh_node_t> LeafNode::allocate(
+eagain_future<LeafNode::fresh_node_t> LeafNode::allocate(
context_t c, field_type_t field_type, bool is_level_tail)
{
return LeafNodeImpl::allocate(c, field_type, is_level_tail
: public boost::intrusive_ref_counter<
tree_cursor_t, boost::thread_unsafe_counter> {
public:
- using ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain>;
- template <class ValueT=void>
- using future = ertr::future<ValueT>;
-
~tree_cursor_t();
tree_cursor_t(const tree_cursor_t&) = delete;
tree_cursor_t(tree_cursor_t&&) = delete;
}
/// Returns the next tree_cursor_t in tree, can be end if there's no next.
- future<Ref<tree_cursor_t>> get_next(context_t);
+ eagain_future<Ref<tree_cursor_t>> get_next(context_t);
/// Check that this is next to prv
void assert_next_to(const tree_cursor_t&, value_magic_t) const;
/// Erases the key-value pair from tree.
template <bool FORCE_MERGE = false>
- future<Ref<tree_cursor_t>> erase(context_t, bool get_next);
+ eagain_future<Ref<tree_cursor_t>> erase(context_t, bool get_next);
MatchKindCMP compare_to(const tree_cursor_t&, value_magic_t) const;
}
/// Extends the size of value payload.
- future<> extend_value(context_t, value_size_t);
+ eagain_future<> extend_value(context_t, value_size_t);
/// Trim and shrink the value payload.
- future<> trim_value(context_t, value_size_t);
+ eagain_future<> trim_value(context_t, value_size_t);
static Ref<tree_cursor_t> get_invalid() {
static Ref<tree_cursor_t> INVALID = new tree_cursor_t();
Node, boost::thread_unsafe_counter> {
public:
// public to Btree
- using node_ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain>;
- template <class ValueT=void>
- using node_future = node_ertr::future<ValueT>;
-
struct search_result_t {
bool is_end() const { return p_cursor->is_end(); }
Ref<tree_cursor_t> p_cursor;
*
* Returns an end cursor if it is an empty root node.
*/
- virtual node_future<Ref<tree_cursor_t>> lookup_smallest(context_t) = 0;
+ virtual eagain_future<Ref<tree_cursor_t>> lookup_smallest(context_t) = 0;
/**
* lookup_largest
*
* Returns an end cursor if it is an empty root node.
*/
- virtual node_future<Ref<tree_cursor_t>> lookup_largest(context_t) = 0;
+ virtual eagain_future<Ref<tree_cursor_t>> lookup_largest(context_t) = 0;
/**
* lower_bound
* - It is an empty root node;
* - Or the input key is larger than all the keys in the sub-tree;
*/
- node_future<search_result_t> lower_bound(context_t c, const key_hobj_t& key);
+ eagain_future<search_result_t> lower_bound(context_t c, const key_hobj_t& key);
/**
* insert
* - If true, the returned cursor points to the inserted element in tree;
* - If false, the returned cursor points to the conflicting element in tree;
*/
- node_future<std::pair<Ref<tree_cursor_t>, bool>> insert(
+ eagain_future<std::pair<Ref<tree_cursor_t>, bool>> insert(
context_t, const key_hobj_t&, value_config_t);
/**
*
* Returns the number of erased key-value pairs (0 or 1).
*/
- node_future<std::size_t> erase(context_t, const key_hobj_t&);
+ eagain_future<std::size_t> erase(context_t, const key_hobj_t&);
/// Recursively collects the statistics of the sub-tree formed by this node
- node_future<tree_stats_t> get_tree_stats(context_t);
+ eagain_future<tree_stats_t> get_tree_stats(context_t);
/// Returns an ostream containing a dump of all the elements in the node.
std::ostream& dump(std::ostream&) const;
const std::string& get_name() const;
/// Initializes the tree by allocating an empty root node.
- static node_future<> mkfs(context_t, RootNodeTracker&);
+ static eagain_future<> mkfs(context_t, RootNodeTracker&);
/// Loads the tree root. The tree must be initialized.
- static node_future<Ref<Node>> load_root(context_t, RootNodeTracker&);
+ static eagain_future<Ref<Node>> load_root(context_t, RootNodeTracker&);
// Only for unit test purposes.
void test_make_destructable(context_t, NodeExtentMutable&, Super::URef&&);
- virtual node_future<> test_clone_root(context_t, RootNodeTracker&) const = 0;
+ virtual eagain_future<> test_clone_root(context_t, RootNodeTracker&) const = 0;
protected:
- virtual node_future<> test_clone_non_root(context_t, Ref<InternalNode>) const {
+ virtual eagain_future<> test_clone_non_root(context_t, Ref<InternalNode>) const {
ceph_abort("impossible path");
}
- virtual node_future<search_result_t> lower_bound_tracked(
+ virtual eagain_future<search_result_t> lower_bound_tracked(
context_t, const key_hobj_t&, MatchHistory&) = 0;
- virtual node_future<> do_get_tree_stats(context_t, tree_stats_t&) = 0;
+ virtual eagain_future<> do_get_tree_stats(context_t, tree_stats_t&) = 0;
virtual bool is_tracking() const = 0;
make_root(c, std::move(_super));
}
void as_root(Super::URef&& _super);
- node_future<> upgrade_root(context_t);
+ eagain_future<> upgrade_root(context_t);
// as child/non-root
template <bool VALIDATE = true>
};
const parent_info_t& parent_info() const { return *_parent_info; }
- node_future<> apply_split_to_parent(context_t, Ref<Node>&&, Ref<Node>&&, bool);
- node_future<Ref<tree_cursor_t>> get_next_cursor_from_parent(context_t);
+ eagain_future<> apply_split_to_parent(context_t, Ref<Node>&&, Ref<Node>&&, bool);
+ eagain_future<Ref<tree_cursor_t>> get_next_cursor_from_parent(context_t);
template <bool FORCE_MERGE = false>
- node_future<> try_merge_adjacent(context_t, bool, Ref<Node>&&);
- node_future<> erase_node(context_t, Ref<Node>&&);
+ eagain_future<> try_merge_adjacent(context_t, bool, Ref<Node>&&);
+ eagain_future<> erase_node(context_t, Ref<Node>&&);
template <bool FORCE_MERGE = false>
- node_future<> fix_parent_index(context_t, Ref<Node>&&, bool);
- node_future<NodeExtentMutable> rebuild_extent(context_t);
- node_future<> retire(context_t, Ref<Node>&&);
+ eagain_future<> fix_parent_index(context_t, Ref<Node>&&, bool);
+ eagain_future<NodeExtentMutable> rebuild_extent(context_t);
+ eagain_future<> retire(context_t, Ref<Node>&&);
void make_tail(context_t);
private:
std::optional<parent_info_t> _parent_info;
private:
- static node_future<Ref<Node>> load(context_t, laddr_t, bool expect_is_level_tail);
+ static eagain_future<Ref<Node>> load(context_t, laddr_t, bool expect_is_level_tail);
NodeImplURef impl;
friend class InternalNode;
InternalNode& operator=(const InternalNode&) = delete;
InternalNode& operator=(InternalNode&&) = delete;
- node_future<Ref<tree_cursor_t>> get_next_cursor(context_t, const search_position_t&);
+ eagain_future<Ref<tree_cursor_t>> get_next_cursor(context_t, const search_position_t&);
- node_future<> apply_child_split(context_t, Ref<Node>&& left, Ref<Node>&& right, bool);
+ eagain_future<> apply_child_split(context_t, Ref<Node>&& left, Ref<Node>&& right, bool);
template <bool VALIDATE>
void do_track_child(Node& child) {
}
}
- node_future<std::pair<Ref<Node>, Ref<Node>>> get_child_peers(
+ eagain_future<std::pair<Ref<Node>, Ref<Node>>> get_child_peers(
context_t, const search_position_t&);
- node_future<> erase_child(context_t, Ref<Node>&&);
+ eagain_future<> erase_child(context_t, Ref<Node>&&);
template <bool FORCE_MERGE = false>
- node_future<> fix_index(context_t, Ref<Node>&&, bool);
+ eagain_future<> fix_index(context_t, Ref<Node>&&, bool);
template <bool FORCE_MERGE = false>
- node_future<> apply_children_merge(
+ eagain_future<> apply_children_merge(
context_t, Ref<Node>&& left, laddr_t, Ref<Node>&& right, bool update_index);
void validate_child_tracked(const Node& child) const {
void track_make_tail(const search_position_t&);
- static node_future<Ref<InternalNode>> allocate_root(
+ static eagain_future<Ref<InternalNode>> allocate_root(
context_t, level_t, laddr_t, Super::URef&&);
protected:
- node_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override;
- node_future<Ref<tree_cursor_t>> lookup_largest(context_t) override;
- node_future<search_result_t> lower_bound_tracked(
+ eagain_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override;
+ eagain_future<Ref<tree_cursor_t>> lookup_largest(context_t) override;
+ eagain_future<search_result_t> lower_bound_tracked(
context_t, const key_hobj_t&, MatchHistory&) override;
- node_future<> do_get_tree_stats(context_t, tree_stats_t&) override;
+ eagain_future<> do_get_tree_stats(context_t, tree_stats_t&) override;
bool is_tracking() const override {
return !tracked_child_nodes.empty();
}
void track_merge(Ref<Node>, match_stage_t, search_position_t&) override;
- node_future<> test_clone_root(context_t, RootNodeTracker&) const override;
+ eagain_future<> test_clone_root(context_t, RootNodeTracker&) const override;
private:
- node_future<> try_downgrade_root(context_t, Ref<Node>&&);
+ eagain_future<> try_downgrade_root(context_t, Ref<Node>&&);
- node_future<Ref<InternalNode>> insert_or_split(
+ eagain_future<Ref<InternalNode>> insert_or_split(
context_t, const search_position_t&, const key_view_t&, Ref<Node>,
Ref<Node> outdated_child=nullptr);
// XXX: extract a common tracker for InternalNode to track Node,
// and LeafNode to track tree_cursor_t.
- node_future<Ref<Node>> get_or_track_child(context_t, const search_position_t&, laddr_t);
+ eagain_future<Ref<Node>> get_or_track_child(context_t, const search_position_t&, laddr_t);
template <bool VALIDATE = true>
void track_insert(
const search_position_t&, match_stage_t, Ref<Node>, Ref<Node> nxt_child = nullptr);
return std::make_pair(Ref<Node>(node), mut);
}
};
- static node_future<fresh_node_t> allocate(context_t, field_type_t, bool, level_t);
+ static eagain_future<fresh_node_t> allocate(context_t, field_type_t, bool, level_t);
private:
/**
node_version_t get_version() const;
const char* read() const;
std::tuple<key_view_t, const value_header_t*> get_kv(const search_position_t&) const;
- node_future<Ref<tree_cursor_t>> get_next_cursor(context_t, const search_position_t&);
+ eagain_future<Ref<tree_cursor_t>> get_next_cursor(context_t, const search_position_t&);
/**
* erase
* pair that followed the erased element, which can be nullptr if is end.
*/
template <bool FORCE_MERGE>
- node_future<Ref<tree_cursor_t>> erase(
+ eagain_future<Ref<tree_cursor_t>> erase(
context_t, const search_position_t&, bool get_next);
template <bool VALIDATE>
}
}
- node_future<> extend_value(context_t, const search_position_t&, value_size_t);
- node_future<> trim_value(context_t, const search_position_t&, value_size_t);
+ eagain_future<> extend_value(context_t, const search_position_t&, value_size_t);
+ eagain_future<> trim_value(context_t, const search_position_t&, value_size_t);
std::pair<NodeExtentMutable&, ValueDeltaRecorder*>
prepare_mutate_value_payload(context_t);
protected:
- node_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override;
- node_future<Ref<tree_cursor_t>> lookup_largest(context_t) override;
- node_future<search_result_t> lower_bound_tracked(
+ eagain_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override;
+ eagain_future<Ref<tree_cursor_t>> lookup_largest(context_t) override;
+ eagain_future<search_result_t> lower_bound_tracked(
context_t, const key_hobj_t&, MatchHistory&) override;
- node_future<> do_get_tree_stats(context_t, tree_stats_t&) override;
+ eagain_future<> do_get_tree_stats(context_t, tree_stats_t&) override;
bool is_tracking() const override {
return !tracked_cursors.empty();
}
void track_merge(Ref<Node>, match_stage_t, search_position_t&) override;
- node_future<> test_clone_root(context_t, RootNodeTracker&) const override;
+ eagain_future<> test_clone_root(context_t, RootNodeTracker&) const override;
private:
LeafNode(LeafNodeImpl*, NodeImplURef&&);
- node_future<Ref<tree_cursor_t>> insert_value(
+ eagain_future<Ref<tree_cursor_t>> insert_value(
context_t, const key_hobj_t&, value_config_t,
const search_position_t&, const MatchHistory&,
match_stat_t mstat);
- static node_future<Ref<LeafNode>> allocate_root(context_t, RootNodeTracker&);
+ static eagain_future<Ref<LeafNode>> allocate_root(context_t, RootNodeTracker&);
friend class Node;
private:
return std::make_pair(Ref<Node>(node), mut);
}
};
- static node_future<fresh_node_t> allocate(context_t, field_type_t, bool);
+ static eagain_future<fresh_node_t> allocate(context_t, field_type_t, bool);
private:
/**
std::memcpy(to.get_write(), extent->get_read(), extent->get_length());
}
- using ertr = NodeExtentManager::tm_ertr;
- ertr::future<NodeExtentMutable> rebuild(context_t c) {
+ eagain_future<NodeExtentMutable> rebuild(context_t c) {
LOG_PREFIX(OTree::Extent::rebuild);
assert(extent->is_valid());
if (state == nextent_state_t::FRESH) {
assert(extent->is_initial_pending());
// already fresh and no need to record
- return ertr::make_ready_future<NodeExtentMutable>(*mut);
+ return eagain_ertr::make_ready_future<NodeExtentMutable>(*mut);
}
assert(!extent->is_initial_pending());
return c.nm.alloc_extent(c.t, node_stage_t::EXTENT_SIZE
});
}
- ertr::future<> retire(context_t c) {
+ eagain_future<> retire(context_t c) {
LOG_PREFIX(OTree::Extent::retire);
assert(extent->is_valid());
auto addr = extent->get_laddr();
public:
virtual ~NodeExtentManager() = default;
- // TODO: remove the coarse-grained errorator
- using tm_ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain>;
-
virtual bool is_read_isolated() const = 0;
using read_ertr = base_ertr::extend<
#endif
// XXX: branchless allocation
-InternalNodeImpl::ertr::future<InternalNodeImpl::fresh_impl_t>
+eagain_future<InternalNodeImpl::fresh_impl_t>
InternalNodeImpl::allocate(
context_t c, field_type_t type, bool is_level_tail, level_t level)
{
}
}
-LeafNodeImpl::ertr::future<LeafNodeImpl::fresh_impl_t>
+eagain_future<LeafNodeImpl::fresh_impl_t>
LeafNodeImpl::allocate(
context_t c, field_type_t type, bool is_level_tail)
{
*/
class NodeImpl {
public:
- using ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain
- >;
virtual ~NodeImpl() = default;
virtual node_type_t node_type() const = 0;
virtual std::tuple<match_stage_t, search_position_t> erase(const search_position_t&) = 0;
virtual std::tuple<match_stage_t, std::size_t> evaluate_merge(NodeImpl&) = 0;
virtual search_position_t merge(NodeExtentMutable&, NodeImpl&, match_stage_t, node_offset_t) = 0;
- virtual ertr::future<NodeExtentMutable> rebuild_extent(context_t) = 0;
- virtual ertr::future<> retire_extent(context_t) = 0;
+ virtual eagain_future<NodeExtentMutable> rebuild_extent(context_t) = 0;
+ virtual eagain_future<> retire_extent(context_t) = 0;
virtual search_position_t make_tail() = 0;
virtual node_stats_t get_stats() const = 0;
return {std::move(impl), mut};
}
};
- static ertr::future<fresh_impl_t> allocate(context_t, field_type_t, bool, level_t);
+ static eagain_future<fresh_impl_t> allocate(context_t, field_type_t, bool, level_t);
static InternalNodeImplURef load(NodeExtentRef, field_type_t, bool);
return {std::move(impl), mut};
}
};
- static ertr::future<fresh_impl_t> allocate(context_t, field_type_t, bool);
+ static eagain_future<fresh_impl_t> allocate(context_t, field_type_t, bool);
static LeafNodeImplURef load(NodeExtentRef, field_type_t, bool);
return ret;
}
- static ertr::future<typename parent_t::fresh_impl_t> allocate(
+ static eagain_future<typename parent_t::fresh_impl_t> allocate(
context_t c, bool is_level_tail, level_t level) {
LOG_PREFIX(OTree::Layout::allocate);
// NOTE: Currently, all the node types have the same size for simplicity.
return normalize(std::move(left_last_pos));
}
- ertr::future<NodeExtentMutable>
+ eagain_future<NodeExtentMutable>
rebuild_extent(context_t c) override {
return extent.rebuild(c).safe_then([this] (auto mut) {
// addr may change
});
}
- ertr::future<> retire_extent(context_t c) override {
+ eagain_future<> retire_extent(context_t c) override {
return extent.retire(c);
}
template <typename ValueImpl>
class Btree {
public:
- using btree_ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain>;
- template <class ValueT=void>
- using btree_future = btree_ertr::future<ValueT>;
-
Btree(NodeExtentManagerURef&& _nm)
: nm{std::move(_nm)},
root_tracker{RootNodeTracker::create(nm->is_read_isolated())} {}
Btree& operator=(const Btree&) = delete;
Btree& operator=(Btree&&) = delete;
- btree_future<> mkfs(Transaction& t) {
+ eagain_future<> mkfs(Transaction& t) {
return Node::mkfs(get_context(t), *root_tracker);
}
bool operator==(const Cursor& o) const { return (int)compare_to(o) == 0; }
bool operator!=(const Cursor& o) const { return (int)compare_to(o) != 0; }
- btree_future<Cursor> get_next(Transaction& t) {
+ eagain_future<Cursor> get_next(Transaction& t) {
assert(!is_end());
auto this_obj = *this;
return p_cursor->get_next(p_tree->get_context(t)
}
template <bool FORCE_MERGE = false>
- btree_future<Cursor> erase(Transaction& t) {
+ eagain_future<Cursor> erase(Transaction& t) {
assert(!is_end());
auto this_obj = *this;
return p_cursor->erase<FORCE_MERGE>(p_tree->get_context(t), true
* lookup
*/
- btree_future<Cursor> begin(Transaction& t) {
+ eagain_future<Cursor> begin(Transaction& t) {
return get_root(t).safe_then([this, &t](auto root) {
return root->lookup_smallest(get_context(t));
}).safe_then([this](auto cursor) {
});
}
- btree_future<Cursor> last(Transaction& t) {
+ eagain_future<Cursor> last(Transaction& t) {
return get_root(t).safe_then([this, &t](auto root) {
return root->lookup_largest(get_context(t));
}).safe_then([this](auto cursor) {
return Cursor::make_end(this);
}
- btree_future<bool> contains(Transaction& t, const ghobject_t& obj) {
+ eagain_future<bool> contains(Transaction& t, const ghobject_t& obj) {
return seastar::do_with(
full_key_t<KeyT::HOBJ>(obj),
- [this, &t](auto& key) -> btree_future<bool> {
+ [this, &t](auto& key) -> eagain_future<bool> {
return get_root(t).safe_then([this, &t, &key](auto root) {
// TODO: improve lower_bound()
return root->lower_bound(get_context(t), key);
);
}
- btree_future<Cursor> find(Transaction& t, const ghobject_t& obj) {
+ eagain_future<Cursor> find(Transaction& t, const ghobject_t& obj) {
return seastar::do_with(
full_key_t<KeyT::HOBJ>(obj),
- [this, &t](auto& key) -> btree_future<Cursor> {
+ [this, &t](auto& key) -> eagain_future<Cursor> {
return get_root(t).safe_then([this, &t, &key](auto root) {
// TODO: improve lower_bound()
return root->lower_bound(get_context(t), key);
);
}
- btree_future<Cursor> lower_bound(Transaction& t, const ghobject_t& obj) {
+ eagain_future<Cursor> lower_bound(Transaction& t, const ghobject_t& obj) {
return seastar::do_with(
full_key_t<KeyT::HOBJ>(obj),
- [this, &t](auto& key) -> btree_future<Cursor> {
+ [this, &t](auto& key) -> eagain_future<Cursor> {
return get_root(t).safe_then([this, &t, &key](auto root) {
return root->lower_bound(get_context(t), key);
}).safe_then([this](auto result) {
);
}
- btree_future<Cursor> get_next(Transaction& t, Cursor& cursor) {
+ eagain_future<Cursor> get_next(Transaction& t, Cursor& cursor) {
return cursor.get_next(t);
}
struct tree_value_config_t {
value_size_t payload_size = 256;
};
- btree_future<std::pair<Cursor, bool>>
+ eagain_future<std::pair<Cursor, bool>>
insert(Transaction& t, const ghobject_t& obj, tree_value_config_t _vconf) {
value_config_t vconf{value_builder.get_header_magic(), _vconf.payload_size};
return seastar::do_with(
full_key_t<KeyT::HOBJ>(obj),
- [this, &t, vconf](auto& key) -> btree_future<std::pair<Cursor, bool>> {
+ [this, &t, vconf](auto& key) -> eagain_future<std::pair<Cursor, bool>> {
ceph_assert(key.is_valid());
return get_root(t).safe_then([this, &t, &key, vconf](auto root) {
return root->insert(get_context(t), key, vconf);
);
}
- btree_future<std::size_t> erase(Transaction& t, const ghobject_t& obj) {
+ eagain_future<std::size_t> erase(Transaction& t, const ghobject_t& obj) {
return seastar::do_with(
full_key_t<KeyT::HOBJ>(obj),
- [this, &t](auto& key) -> btree_future<std::size_t> {
+ [this, &t](auto& key) -> eagain_future<std::size_t> {
return get_root(t).safe_then([this, &t, &key](auto root) {
return root->erase(get_context(t), key);
});
);
}
- btree_future<Cursor> erase(Transaction& t, Cursor& pos) {
+ eagain_future<Cursor> erase(Transaction& t, Cursor& pos) {
return pos.erase(t);
}
- btree_future<> erase(Transaction& t, Value& value) {
+ eagain_future<> erase(Transaction& t, Value& value) {
assert(value.is_tracked());
auto ref_cursor = value.p_cursor;
return ref_cursor->erase(get_context(t), false
* stats
*/
- btree_future<size_t> height(Transaction& t) {
+ eagain_future<size_t> height(Transaction& t) {
return get_root(t).safe_then([](auto root) {
return size_t(root->level() + 1);
});
}
- btree_future<tree_stats_t> get_stats_slow(Transaction& t) {
+ eagain_future<tree_stats_t> get_stats_slow(Transaction& t) {
return get_root(t).safe_then([this, &t](auto root) {
unsigned height = root->level() + 1;
return root->get_tree_stats(get_context(t)
).safe_then([height](auto stats) {
stats.height = height;
- return btree_ertr::make_ready_future<tree_stats_t>(stats);
+ return seastar::make_ready_future<tree_stats_t>(stats);
});
});
}
return root_tracker->is_clean();
}
- btree_future<> test_clone_from(
+ eagain_future<> test_clone_from(
Transaction& t, Transaction& t_from, Btree& from) {
// Note: assume the tree to clone is tracked correctly in memory.
// In some unit tests, parts of the tree are stubbed out that they
return {*nm, value_builder, t};
}
- btree_future<Ref<Node>> get_root(Transaction& t) {
+ eagain_future<Ref<Node>> get_root(Transaction& t) {
auto root = root_tracker->get_root(t);
if (root) {
- return btree_ertr::make_ready_future<Ref<Node>>(root);
+ return seastar::make_ready_future<Ref<Node>>(root);
} else {
return Node::load_root(get_context(t), *root_tracker);
}
public:
using BtreeImpl = Btree<typename ValueItem::ValueType>;
using BtreeCursor = typename BtreeImpl::Cursor;
- using ertr = typename BtreeImpl::btree_ertr;
- template <class ValueT=void>
- using future = typename ertr::template future<ValueT>;
using iterator_t = typename KVPool<ValueItem>::iterator_t;
TreeBuilder(KVPool<ValueItem>& kvs, NodeExtentManagerURef&& nm)
tree.emplace(std::move(nm));
}
- future<> bootstrap(Transaction& t) {
+ eagain_future<> bootstrap(Transaction& t) {
std::ostringstream oss;
#ifndef NDEBUG
oss << "debug=on, ";
return tree->mkfs(t);
}
- future<> insert(Transaction& t) {
+ eagain_future<> insert(Transaction& t) {
auto ref_kv_iter = seastar::make_lw_shared<iterator_t>();
*ref_kv_iter = kvs.random_begin();
auto cursors = seastar::make_lw_shared<std::vector<BtreeCursor>>();
logger().warn("start inserting {} kvs ...", kvs.size());
auto start_time = mono_clock::now();
return crimson::do_until([&t, this, cursors, ref_kv_iter,
- start_time]() -> future<bool> {
+ start_time]() -> eagain_future<bool> {
if (*ref_kv_iter == kvs.random_end()) {
std::chrono::duration<double> duration = mono_clock::now() - start_time;
logger().warn("Insert done! {}s", duration.count());
- return ertr::template make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
auto p_kv = **ref_kv_iter;
logger().debug("[{}] insert {} -> {}",
ceph_assert(cursor_.value() == cursor.value());
validate_cursor_from_item(p_kv->key, p_kv->value, cursor_);
++(*ref_kv_iter);
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
});
#else
++(*ref_kv_iter);
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
#endif
});
}).safe_then([&t, this, cursors, ref_kv_iter] {
logger().info("Verifing tracked cursors ...");
*ref_kv_iter = kvs.random_begin();
return seastar::do_with(
- cursors->begin(), [&t, this, cursors, ref_kv_iter](auto& c_iter) {
- return crimson::do_until([&t, this, &c_iter, cursors, ref_kv_iter]() -> future<bool> {
+ cursors->begin(),
+ [&t, this, cursors, ref_kv_iter] (auto& c_iter) {
+ return crimson::do_until(
+ [&t, this, &c_iter, cursors, ref_kv_iter] () -> eagain_future<bool> {
if (*ref_kv_iter == kvs.random_end()) {
logger().info("Verify done!");
- return ertr::template make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
assert(c_iter != cursors->end());
auto p_kv = **ref_kv_iter;
validate_cursor_from_item(p_kv->key, p_kv->value, *c_iter);
++(*ref_kv_iter);
++c_iter;
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
});
});
});
} else {
- return ertr::now();
+ return eagain_ertr::now();
}
});
}
- future<> erase(Transaction& t, std::size_t erase_size) {
+ eagain_future<> erase(Transaction& t, std::size_t erase_size) {
assert(erase_size <= kvs.size());
kvs.shuffle();
auto begin = kvs.random_begin();
auto end = begin + erase_size;
auto ref_kv_iter = seastar::make_lw_shared<iterator_t>();
auto cursors = seastar::make_lw_shared<std::map<ghobject_t, BtreeCursor>>();
- return ertr::now().safe_then([&t, this, cursors, ref_kv_iter] {
+ return seastar::now().then([&t, this, cursors, ref_kv_iter] {
if constexpr (TRACK) {
logger().info("Tracking cursors before erase ...");
*ref_kv_iter = kvs.begin();
auto start_time = mono_clock::now();
- return crimson::do_until([&t, this, cursors, ref_kv_iter, start_time] () -> future<bool> {
+ return crimson::do_until(
+ [&t, this, cursors, ref_kv_iter, start_time] () -> eagain_future<bool> {
if (*ref_kv_iter == kvs.end()) {
std::chrono::duration<double> duration = mono_clock::now() - start_time;
logger().info("Track done! {}s", duration.count());
- return ertr::template make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
auto p_kv = **ref_kv_iter;
return tree->find(t, p_kv->key).safe_then([this, cursors, ref_kv_iter](auto cursor) {
validate_cursor_from_item(p_kv->key, p_kv->value, cursor);
cursors->emplace(p_kv->key, cursor);
++(*ref_kv_iter);
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
});
});
} else {
- return ertr::now();
+ return eagain_ertr::now();
}
}).safe_then([&t, this, ref_kv_iter, begin, end] {
*ref_kv_iter = begin;
logger().warn("start erasing {}/{} kvs ...", end - begin, kvs.size());
auto start_time = mono_clock::now();
return crimson::do_until([&t, this, ref_kv_iter,
- start_time, begin, end] () -> future<bool> {
+ start_time, begin, end] () -> eagain_future<bool> {
if (*ref_kv_iter == end) {
std::chrono::duration<double> duration = mono_clock::now() - start_time;
logger().warn("Erase done! {}s", duration.count());
- return ertr::template make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
auto p_kv = **ref_kv_iter;
logger().debug("[{}] erase {} -> {}",
return tree->contains(t, p_kv->key).safe_then([ref_kv_iter] (bool ret) {
ceph_assert(ret == false);
++(*ref_kv_iter);
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
});
#else
++(*ref_kv_iter);
- return ertr::template make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
#endif
});
});
});
}
- future<> get_stats(Transaction& t) {
+ eagain_future<> get_stats(Transaction& t) {
return tree->get_stats_slow(t
).safe_then([this](auto stats) {
logger().warn("{}", stats);
});
}
- future<std::size_t> height(Transaction& t) {
+ eagain_future<std::size_t> height(Transaction& t) {
return tree->height(t);
}
tree.emplace(std::move(nm));
}
- future<> validate(Transaction& t) {
+ eagain_future<> validate(Transaction& t) {
return seastar::async([this, &t] {
logger().info("Verifing inserted ...");
for (auto& p_kv : kvs) {
namespace crimson::os::seastore::onode {
-using ertr = Value::ertr;
-template <class ValueT=void>
-using future = Value::future<ValueT>;
-
ceph::bufferlist&
ValueDeltaRecorder::get_encoded(NodeExtentMutable& payload_mut)
{
return p_cursor->is_tracked();
}
-future<> Value::extend(Transaction& t, value_size_t extend_size)
+eagain_future<> Value::extend(Transaction& t, value_size_t extend_size)
{
assert(is_tracked());
[[maybe_unused]] auto target_size = get_payload_size() + extend_size;
;
}
-future<> Value::trim(Transaction& t, value_size_t trim_size)
+eagain_future<> Value::trim(Transaction& t, value_size_t trim_size)
{
assert(is_tracked());
assert(get_payload_size() > trim_size);
*/
class Value {
public:
- using ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::invarg,
- crimson::ct_error::enoent,
- crimson::ct_error::erange,
- crimson::ct_error::eagain>;
- template <class ValueT=void>
- using future = ertr::future<ValueT>;
-
virtual ~Value();
Value(const Value&) = default;
Value(Value&&) = default;
Value(NodeExtentManager&, const ValueBuilder&, Ref<tree_cursor_t>&);
/// Extends the payload size.
- future<> extend(Transaction&, value_size_t extend_size);
+ eagain_future<> extend(Transaction&, value_size_t extend_size);
/// Trim and shrink the payload.
- future<> trim(Transaction&, value_size_t trim_size);
+ eagain_future<> trim(Transaction&, value_size_t trim_size);
/// Get the permission to mutate the payload with the optional value recorder.
template <typename PayloadT, typename ValueDeltaRecorderT>
build_name();
return search_position_t::end();
}
- ertr::future<> retire_extent(context_t) override {
+ eagain_future<> retire_extent(context_t) override {
_is_extent_valid = false;
- return ertr::now();
+ return seastar::now();
}
protected:
ceph_abort("impossible path"); }
search_position_t merge(NodeExtentMutable&, NodeImpl&, match_stage_t, node_offset_t) override {
ceph_abort("impossible path"); }
- ertr::future<NodeExtentMutable> rebuild_extent(context_t) override {
+ eagain_future<NodeExtentMutable> rebuild_extent(context_t) override {
ceph_abort("impossible path"); }
node_stats_t get_stats() const override {
ceph_abort("impossible path"); }
key_view_t get_pivot_key() const { return *impl->get_pivot_index(); }
- node_future<> populate_split(
+ eagain_future<> populate_split(
context_t c, std::set<Ref<DummyChild>>& splitable_nodes) {
ceph_assert(can_split());
ceph_assert(splitable_nodes.find(this) != splitable_nodes.end());
c, std::move(this_ref), std::move(right_child), false);
}
- node_future<> insert_and_split(
+ eagain_future<> insert_and_split(
context_t c, const ghobject_t& insert_key,
std::set<Ref<DummyChild>>& splitable_nodes) {
const auto& keys = impl->get_keys();
return fut;
}
- node_future<> merge(context_t c, Ref<DummyChild>&& this_ref) {
+ eagain_future<> merge(context_t c, Ref<DummyChild>&& this_ref) {
return parent_info().ptr->get_child_peers(c, parent_info().position
).safe_then([c, this_ref = std::move(this_ref), this] (auto lr_nodes) mutable {
auto& [lnode, rnode] = lr_nodes;
});
}
- node_future<> fix_key(context_t c, const ghobject_t& new_key) {
+ eagain_future<> fix_key(context_t c, const ghobject_t& new_key) {
const auto& keys = impl->get_keys();
ceph_assert(keys.size() == 1);
assert(impl->is_level_tail() == false);
return create(keys, is_level_tail, seed++, pool);
}
- static node_future<Ref<DummyChild>> create_initial(
+ static eagain_future<Ref<DummyChild>> create_initial(
context_t c, const std::set<ghobject_t>& keys,
DummyChildPool& pool, RootNodeTracker& root_tracker) {
auto initial = create_new(keys, true, pool);
}
protected:
- node_future<> test_clone_non_root(
+ eagain_future<> test_clone_non_root(
context_t, Ref<InternalNode> new_parent) const override {
ceph_assert(!is_root());
auto p_pool_clone = pool.pool_clone_in_progress;
auto clone = create(
impl->get_keys(), impl->is_level_tail(), impl->laddr(), *p_pool_clone);
clone->as_child(parent_info().position, new_parent);
- return node_ertr::now();
+ return seastar::now();
}
- node_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override {
+ eagain_future<Ref<tree_cursor_t>> lookup_smallest(context_t) override {
ceph_abort("impossible path"); }
- node_future<Ref<tree_cursor_t>> lookup_largest(context_t) override {
+ eagain_future<Ref<tree_cursor_t>> lookup_largest(context_t) override {
ceph_abort("impossible path"); }
- node_future<> test_clone_root(context_t, RootNodeTracker&) const override {
+ eagain_future<> test_clone_root(context_t, RootNodeTracker&) const override {
ceph_abort("impossible path"); }
- node_future<search_result_t> lower_bound_tracked(
+ eagain_future<search_result_t> lower_bound_tracked(
context_t, const key_hobj_t&, MatchHistory&) override {
ceph_abort("impossible path"); }
- node_future<> do_get_tree_stats(context_t, tree_stats_t&) override {
+ eagain_future<> do_get_tree_stats(context_t, tree_stats_t&) override {
ceph_abort("impossible path"); }
bool is_tracking() const override { return false; }
void track_merge(Ref<Node>, match_stage_t, search_position_t&) override {
bool can_split() const { return impl->get_keys().size() > 1; }
- static node_future<> do_merge(
+ static eagain_future<> do_merge(
context_t c, Ref<DummyChild>&& left, Ref<DummyChild>&& right, bool stole_key) {
assert(right->use_count() == 1);
assert(left->impl->get_keys().size() == 1);
};
public:
- using node_ertr = Node::node_ertr;
- template <class ValueT=void>
- using node_future = Node::node_future<ValueT>;
-
DummyChildPool() = default;
~DummyChildPool() { reset(); }
- node_future<> build_tree(const std::set<ghobject_t>& keys) {
+ eagain_future<> build_tree(const std::set<ghobject_t>& keys) {
reset();
// create tree
).safe_then([this](auto initial_child) {
// split
splitable_nodes.insert(initial_child);
- return crimson::do_until([this] {
+ return crimson::do_until([this] () -> eagain_future<bool> {
if (splitable_nodes.empty()) {
- return node_ertr::make_ready_future<bool>(true);
+ return seastar::make_ready_future<bool>(true);
}
auto index = rd() % splitable_nodes.size();
auto iter = splitable_nodes.begin();
Ref<DummyChild> child = *iter;
return child->populate_split(get_context(), splitable_nodes
).safe_then([] {
- return node_ertr::make_ready_future<bool>(false);
+ return seastar::make_ready_future<bool>(false);
});
});
}).safe_then([this] {
projects / ceph.git / commitdiff