From 2860d003602a1e1f2a95df41cfb34d911fc83a90 Mon Sep 17 00:00:00 2001 From: Yingxin Cheng Date: Fri, 14 May 2021 11:16:36 +0800 Subject: [PATCH] crimson/onode-staged-tree: use eagain_future/ertr internally Signed-off-by: Yingxin Cheng --- .../staged-fltree/fltree_onode_manager.cc | 5 +- .../onode_manager/staged-fltree/fwd.h | 2 + .../onode_manager/staged-fltree/node.cc | 206 +++++++++--------- .../onode_manager/staged-fltree/node.h | 124 +++++------ .../staged-fltree/node_extent_accessor.h | 7 +- .../staged-fltree/node_extent_manager.h | 8 - .../onode_manager/staged-fltree/node_impl.cc | 4 +- .../onode_manager/staged-fltree/node_impl.h | 15 +- .../onode_manager/staged-fltree/node_layout.h | 6 +- .../onode_manager/staged-fltree/tree.h | 57 ++--- .../onode_manager/staged-fltree/tree_utils.h | 54 ++--- .../onode_manager/staged-fltree/value.cc | 8 +- .../onode_manager/staged-fltree/value.h | 13 +- .../seastore/onode_tree/test_staged_fltree.cc | 44 ++-- 14 files changed, 244 insertions(+), 309 deletions(-) diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc index cfede0b511a89..bdd8ba556a0f8 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc @@ -107,7 +107,7 @@ FLTreeOnodeManager::write_dirty_ret FLTreeOnodeManager::write_dirty( { return crimson::do_for_each( onodes, - [this, &trans](auto &onode) -> OnodeTree::btree_future<> { + [this, &trans](auto &onode) -> eagain_future<> { auto &flonode = static_cast(*onode); switch (flonode.status) { case FLTreeOnode::status_t::MUTATED: { @@ -154,10 +154,9 @@ FLTreeOnodeManager::list_onodes_ret FLTreeOnodeManager::list_onodes( 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 { + -> eagain_future { if (current_cursor.is_end() || current_cursor.get_ghobj() >= end) { std::get<1>(ret) = end; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h b/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h index f23e44a083826..881d9c91be5e6 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/fwd.h @@ -19,6 +19,8 @@ namespace crimson::os::seastore::onode { using eagain_ertr = crimson::errorator< crimson::ct_error::eagain>; +template +using eagain_future = eagain_ertr::future; using crimson::os::seastore::Transaction; using crimson::os::seastore::TransactionRef; diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc index a96729f4bbdf4..fdcdc8668fa3e 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc @@ -15,11 +15,6 @@ #include "stages/node_stage_layout.h" namespace crimson::os::seastore::onode { - -using node_ertr = Node::node_ertr; -template -using node_future = Node::node_future; - /* * tree_cursor_t */ @@ -55,7 +50,7 @@ tree_cursor_t::~tree_cursor_t() } } -tree_cursor_t::future> +eagain_future> tree_cursor_t::get_next(context_t c) { assert(is_tracked()); @@ -88,15 +83,15 @@ void tree_cursor_t::assert_next_to( } template -tree_cursor_t::future> +eagain_future> tree_cursor_t::erase(context_t c, bool get_next) { assert(is_tracked()); return ref_leaf_node->erase(c, position, get_next); } -template tree_cursor_t::future> +template eagain_future> tree_cursor_t::erase(context_t, bool); -template tree_cursor_t::future> +template eagain_future> tree_cursor_t::erase(context_t, bool); MatchKindCMP tree_cursor_t::compare_to( @@ -128,14 +123,14 @@ 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()); @@ -309,7 +304,7 @@ level_t Node::level() const return impl->level(); } -node_future Node::lower_bound( +eagain_future Node::lower_bound( context_t c, const key_hobj_t& key) { return seastar::do_with( @@ -319,7 +314,7 @@ node_future Node::lower_bound( ); } -node_future, bool>> Node::insert( +eagain_future, bool>> Node::insert( context_t c, const key_hobj_t& key, value_config_t vconf) { return seastar::do_with( @@ -327,14 +322,14 @@ node_future, bool>> Node::insert( 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, bool>>( + return eagain_ertr::make_ready_future, 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, bool>>( + return seastar::make_ready_future, bool>>( std::make_pair(p_cursor, true)); }); } @@ -343,12 +338,12 @@ node_future, bool>> Node::insert( ); } -node_future Node::erase( +eagain_future 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(0); + return eagain_ertr::make_ready_future(0); } auto ref_cursor = result.p_cursor; return ref_cursor->erase(c, false @@ -360,7 +355,7 @@ node_future Node::erase( }); } -node_future Node::get_tree_stats(context_t c) +eagain_future Node::get_tree_stats(context_t c) { return seastar::do_with( tree_stats_t(), [this, c](auto& stats) { @@ -393,7 +388,7 @@ void Node::test_make_destructable( 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 @@ -402,7 +397,7 @@ node_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker) }); } -node_future> Node::load_root(context_t c, RootNodeTracker& root_tracker) +eagain_future> Node::load_root(context_t c, RootNodeTracker& root_tracker) { LOG_PREFIX(OTree::Node::load_root); return c.nm.get_super(c.t, root_tracker @@ -424,7 +419,7 @@ node_future> Node::load_root(context_t c, RootNodeTracker& root_tracke 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>(root); + return seastar::make_ready_future>(root); }); }); } @@ -444,7 +439,7 @@ void Node::as_root(Super::URef&& _super) 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()); @@ -475,7 +470,7 @@ void Node::as_child(const search_position_t& pos, Ref parent_node) template void Node::as_child(const search_position_t&, Ref); template void Node::as_child(const search_position_t&, Ref); -node_future<> Node::apply_split_to_parent( +eagain_future<> Node::apply_split_to_parent( context_t c, Ref&& this_ref, Ref&& split_right, @@ -488,7 +483,7 @@ node_future<> Node::apply_split_to_parent( c, std::move(this_ref), std::move(split_right), update_right_index); } -node_future> +eagain_future> Node::get_next_cursor_from_parent(context_t c) { assert(!impl->is_level_tail()); @@ -497,7 +492,7 @@ Node::get_next_cursor_from_parent(context_t c) } template -node_future<> +eagain_future<> Node::try_merge_adjacent( context_t c, bool update_parent_index, Ref&& this_ref) { @@ -511,14 +506,14 @@ Node::try_merge_adjacent( 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 left_for_merge; Ref right_for_merge; @@ -601,15 +596,15 @@ Node::try_merge_adjacent( 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(context_t, bool, Ref&&); -template node_future<> Node::try_merge_adjacent(context_t, bool, Ref&&); +template eagain_future<> Node::try_merge_adjacent(context_t, bool, Ref&&); +template eagain_future<> Node::try_merge_adjacent(context_t, bool, Ref&&); -node_future<> Node::erase_node(context_t c, Ref&& this_ref) +eagain_future<> Node::erase_node(context_t c, Ref&& this_ref) { assert(this_ref.get() == this); assert(!is_tracking()); @@ -619,7 +614,7 @@ node_future<> Node::erase_node(context_t c, Ref&& this_ref) } template -node_future<> Node::fix_parent_index( +eagain_future<> Node::fix_parent_index( context_t c, Ref&& this_ref, bool check_downgrade) { assert(!is_root()); @@ -631,10 +626,10 @@ node_future<> Node::fix_parent_index( parent->validate_tracked_children(); return parent->fix_index(c, std::move(this_ref), check_downgrade); } -template node_future<> Node::fix_parent_index(context_t, Ref&&, bool); -template node_future<> Node::fix_parent_index(context_t, Ref&&, bool); +template eagain_future<> Node::fix_parent_index(context_t, Ref&&, bool); +template eagain_future<> Node::fix_parent_index(context_t, Ref&&, bool); -node_future> Node::load( +eagain_future> Node::load( context_t c, laddr_t addr, bool expect_is_level_tail) { LOG_PREFIX(OTree::Node::load); @@ -683,7 +678,7 @@ node_future> Node::load( }); } -node_future Node::rebuild_extent(context_t c) +eagain_future Node::rebuild_extent(context_t c) { LOG_PREFIX(OTree::Node::rebuild_extent); DEBUGT("{} ...", c.t, get_name()); @@ -695,7 +690,7 @@ node_future Node::rebuild_extent(context_t c) return impl->rebuild_extent(c); } -node_future<> Node::retire(context_t c, Ref&& this_ref) +eagain_future<> Node::retire(context_t c, Ref&& this_ref) { LOG_PREFIX(OTree::Node::retire); DEBUGT("{} ...", c.t, get_name()); @@ -731,7 +726,7 @@ void Node::make_tail(context_t c) InternalNode::InternalNode(InternalNodeImpl* impl, NodeImplURef&& impl_ref) : Node(std::move(impl_ref)), impl{impl} {} -node_future> +eagain_future> InternalNode::get_next_cursor(context_t c, const search_position_t& pos) { impl->validate_non_empty(); @@ -757,7 +752,7 @@ InternalNode::get_next_cursor(context_t c, const search_position_t& pos) } } -node_future<> InternalNode::apply_child_split( +eagain_future<> InternalNode::apply_child_split( context_t c, Ref&& left_child, Ref&& right_child, bool update_right_index) { @@ -802,7 +797,7 @@ node_future<> InternalNode::apply_child_split( 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 { @@ -814,12 +809,12 @@ node_future<> InternalNode::apply_child_split( // 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&& child_ref) +eagain_future<> InternalNode::erase_child(context_t c, Ref&& child_ref) { LOG_PREFIX(OTree::InternalNode::erase_child); // this is a special version of recursive merge @@ -831,14 +826,14 @@ node_future<> InternalNode::erase_child(context_t c, Ref&& child_ref) // 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>(); + return eagain_ertr::make_ready_future>(); } }).safe_then([c, this, child_ref = std::move(child_ref), FNAME] (auto&& new_tail_child) mutable { @@ -934,14 +929,14 @@ node_future<> InternalNode::erase_child(context_t c, Ref&& child_ref) return new_tail_child->try_merge_adjacent( c, false, std::move(new_tail_child)); } else { - return node_ertr::now(); + return eagain_ertr::now(); } }); }); } template -node_future<> InternalNode::fix_index( +eagain_future<> InternalNode::fix_index( context_t c, Ref&& child, bool check_downgrade) { LOG_PREFIX(OTree::InternalNode::fix_index); @@ -990,7 +985,7 @@ node_future<> 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, @@ -1003,7 +998,7 @@ node_future<> InternalNode::fix_index( } template -node_future<> InternalNode::apply_children_merge( +eagain_future<> InternalNode::apply_children_merge( context_t c, Ref&& left_child, laddr_t origin_left_addr, Ref&& right_child, bool update_index) { @@ -1082,12 +1077,12 @@ node_future<> InternalNode::apply_children_merge( } }); } -template node_future<> InternalNode::apply_children_merge( +template eagain_future<> InternalNode::apply_children_merge( context_t, Ref&&, laddr_t, Ref&&, bool); -template node_future<> InternalNode::apply_children_merge( +template eagain_future<> InternalNode::apply_children_merge( context_t, Ref&&, laddr_t, Ref&&, bool); -node_future, Ref>> InternalNode::get_child_peers( +eagain_future, Ref>> InternalNode::get_child_peers( context_t c, const search_position_t& pos) { // assume I'm already ref counted by caller @@ -1136,27 +1131,27 @@ node_future, Ref>> InternalNode::get_child_peers( } } - 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>(); + return eagain_ertr::make_ready_future>(); } }).safe_then([this, c, next_pos, next_p_child_addr] (Ref lnode) { if (next_p_child_addr != nullptr) { return get_or_track_child(c, next_pos, next_p_child_addr->value ).safe_then([lnode] (Ref rnode) { - return node_ertr::make_ready_future, Ref>>( + return seastar::make_ready_future, Ref>>( lnode, rnode); }); } else { - return node_ertr::make_ready_future, Ref>>( + return eagain_ertr::make_ready_future, Ref>>( lnode, nullptr); } }); } -node_future> InternalNode::allocate_root( +eagain_future> InternalNode::allocate_root( context_t c, level_t old_root_level, laddr_t old_root_addr, Super::URef&& super) { @@ -1173,7 +1168,7 @@ node_future> InternalNode::allocate_root( }); } -node_future> +eagain_future> InternalNode::lookup_smallest(context_t c) { impl->validate_non_empty(); @@ -1186,7 +1181,7 @@ InternalNode::lookup_smallest(context_t c) }); } -node_future> +eagain_future> InternalNode::lookup_largest(context_t c) { // NOTE: unlike LeafNode::lookup_largest(), this only works for the tail @@ -1200,7 +1195,7 @@ InternalNode::lookup_largest(context_t c) }); } -node_future +eagain_future InternalNode::lower_bound_tracked( context_t c, const key_hobj_t& key, MatchHistory& history) { @@ -1212,7 +1207,7 @@ InternalNode::lower_bound_tracked( }); } -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(); @@ -1232,24 +1227,24 @@ node_future<> InternalNode::do_get_tree_stats( 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 { + [this, this_ref, c, &stats, &pos, &p_child_addr]() -> eagain_future { 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(true); + return seastar::make_ready_future(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(false); + return seastar::make_ready_future(false); } else { - return node_ertr::make_ready_future(true); + return seastar::make_ready_future(true); } } else { - return node_ertr::make_ready_future(false); + return seastar::make_ready_future(false); } } }); @@ -1312,7 +1307,7 @@ void InternalNode::track_merge( 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()); @@ -1346,7 +1341,7 @@ node_future<> InternalNode::test_clone_root( }); } -node_future<> InternalNode::try_downgrade_root( +eagain_future<> InternalNode::try_downgrade_root( context_t c, Ref&& this_ref) { LOG_PREFIX(OTree::InternalNode::try_downgrade_root); @@ -1355,7 +1350,7 @@ node_future<> 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 @@ -1381,7 +1376,7 @@ node_future<> InternalNode::try_downgrade_root( }); } -node_future> InternalNode::insert_or_split( +eagain_future> InternalNode::insert_or_split( context_t c, const search_position_t& pos, const key_view_t& insert_key, @@ -1423,12 +1418,12 @@ node_future> InternalNode::insert_or_split( } validate_tracked_children(); - return node_ertr::make_ready_future>(nullptr); + return eagain_ertr::make_ready_future>(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()); @@ -1475,7 +1470,7 @@ node_future> InternalNode::insert_or_split( }); } -node_future> InternalNode::get_or_track_child( +eagain_future> 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); @@ -1493,7 +1488,7 @@ node_future> InternalNode::get_or_track_child( })) : (TRACET("loaded child tracked {} at pos({})", c.t, found->second->get_name(), position), - node_ertr::make_ready_future>(found->second)) + eagain_ertr::make_ready_future>(found->second)) ).safe_then([this_ref, this, position, child_addr] (auto child) { assert(child_addr == child->impl->laddr()); assert(position == child->parent_info().position); @@ -1664,7 +1659,7 @@ void InternalNode::validate_child_inconsistent(const Node& child) const #endif } -node_future InternalNode::allocate( +eagain_future 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 @@ -1706,7 +1701,7 @@ LeafNode::get_kv(const search_position_t& pos) const return {key_view, p_value_header}; } -node_future> +eagain_future> LeafNode::get_next_cursor(context_t c, const search_position_t& pos) { impl->validate_non_empty(); @@ -1716,19 +1711,19 @@ LeafNode::get_next_cursor(context_t c, const search_position_t& pos) 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>( + return eagain_ertr::make_ready_future>( tree_cursor_t::create_end(this)); } else { return get_next_cursor_from_parent(c); } } else { - return node_ertr::make_ready_future>( + return eagain_ertr::make_ready_future>( get_or_track_cursor(next_pos, index_key, p_value_header)); } } template -node_future> +eagain_future> LeafNode::erase(context_t c, const search_position_t& pos, bool get_next) { LOG_PREFIX(OTree::LeafNode::erase); @@ -1739,11 +1734,11 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next) 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>(); + return eagain_ertr::make_ready_future>(); } }).safe_then([c, &pos, this_ref = std::move(this_ref), this, FNAME] (Ref next_cursor) { @@ -1751,9 +1746,8 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next) // 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()) { @@ -1783,7 +1777,7 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next) validate_tracked_cursors(); if (is_root()) { - return node_ertr::now(); + return eagain_ertr::now(); } else { bool update_parent_index; if (impl->is_level_tail()) { @@ -1800,23 +1794,23 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next) }); }); } -template node_future> +template eagain_future> LeafNode::erase(context_t, const search_position_t&, bool); -template node_future> +template eagain_future> LeafNode::erase(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 @@ -1825,39 +1819,39 @@ LeafNode::prepare_mutate_value_payload(context_t c) return impl->prepare_mutate_value_payload(c); } -node_future> +eagain_future> LeafNode::lookup_smallest(context_t) { if (unlikely(impl->is_keys_empty())) { assert(is_root()); - return node_ertr::make_ready_future>( + return seastar::make_ready_future>( 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>( + return seastar::make_ready_future>( get_or_track_cursor(pos, index_key, p_value_header)); } -node_future> +eagain_future> LeafNode::lookup_largest(context_t) { if (unlikely(impl->is_keys_empty())) { assert(is_root()); - return node_ertr::make_ready_future>( + return seastar::make_ready_future>( 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>( + return seastar::make_ready_future>( get_or_track_cursor(pos, index_key, p_value_header)); } -node_future +eagain_future LeafNode::lower_bound_tracked( context_t c, const key_hobj_t& key, MatchHistory& history) { @@ -1872,10 +1866,10 @@ LeafNode::lower_bound_tracked( } search_result_t ret{cursor, result.mstat}; ret.validate_input_key(key, c.vb.get_header_magic()); - return node_ertr::make_ready_future(ret); + return seastar::make_ready_future(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; @@ -1885,7 +1879,7 @@ node_future<> LeafNode::do_get_tree_stats(context_t, tree_stats_t& stats) 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( @@ -1931,7 +1925,7 @@ 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()); @@ -1952,7 +1946,7 @@ node_future<> LeafNode::test_clone_root( }).safe_then([this_ref]{}); } -node_future> LeafNode::insert_value( +eagain_future> 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) @@ -1980,11 +1974,11 @@ node_future> LeafNode::insert_value( 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>(ret); + return eagain_ertr::make_ready_future>(ret); } // split and insert Ref 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, @@ -2019,7 +2013,7 @@ node_future> LeafNode::insert_value( }); } -node_future> LeafNode::allocate_root( +eagain_future> LeafNode::allocate_root( context_t c, RootNodeTracker& root_tracker) { LOG_PREFIX(OTree::LeafNode::allocate_root); @@ -2138,7 +2132,7 @@ void LeafNode::track_erase( } } -node_future LeafNode::allocate( +eagain_future LeafNode::allocate( context_t c, field_type_t field_type, bool is_level_tail) { return LeafNodeImpl::allocate(c, field_type, is_level_tail diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node.h index cd6451a15e143..8b42d67a1faff 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.h @@ -74,15 +74,6 @@ class tree_cursor_t final : 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 - using future = ertr::future; - ~tree_cursor_t(); tree_cursor_t(const tree_cursor_t&) = delete; tree_cursor_t(tree_cursor_t&&) = delete; @@ -123,14 +114,14 @@ class tree_cursor_t final } /// Returns the next tree_cursor_t in tree, can be end if there's no next. - future> get_next(context_t); + eagain_future> 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 - future> erase(context_t, bool get_next); + eagain_future> erase(context_t, bool get_next); MatchKindCMP compare_to(const tree_cursor_t&, value_magic_t) const; @@ -150,10 +141,10 @@ class tree_cursor_t final } /// 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 get_invalid() { static Ref INVALID = new tree_cursor_t(); @@ -259,15 +250,6 @@ class Node 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 - using node_future = node_ertr::future; - struct search_result_t { bool is_end() const { return p_cursor->is_end(); } Ref p_cursor; @@ -319,7 +301,7 @@ class Node * * Returns an end cursor if it is an empty root node. */ - virtual node_future> lookup_smallest(context_t) = 0; + virtual eagain_future> lookup_smallest(context_t) = 0; /** * lookup_largest @@ -329,7 +311,7 @@ class Node * * Returns an end cursor if it is an empty root node. */ - virtual node_future> lookup_largest(context_t) = 0; + virtual eagain_future> lookup_largest(context_t) = 0; /** * lower_bound @@ -342,7 +324,7 @@ class Node * - It is an empty root node; * - Or the input key is larger than all the keys in the sub-tree; */ - node_future lower_bound(context_t c, const key_hobj_t& key); + eagain_future lower_bound(context_t c, const key_hobj_t& key); /** * insert @@ -353,7 +335,7 @@ class Node * - 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, bool>> insert( + eagain_future, bool>> insert( context_t, const key_hobj_t&, value_config_t); /** @@ -363,10 +345,10 @@ class Node * * Returns the number of erased key-value pairs (0 or 1). */ - node_future erase(context_t, const key_hobj_t&); + eagain_future erase(context_t, const key_hobj_t&); /// Recursively collects the statistics of the sub-tree formed by this node - node_future get_tree_stats(context_t); + eagain_future get_tree_stats(context_t); /// Returns an ostream containing a dump of all the elements in the node. std::ostream& dump(std::ostream&) const; @@ -378,22 +360,22 @@ class Node 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> load_root(context_t, RootNodeTracker&); + static eagain_future> 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) const { + virtual eagain_future<> test_clone_non_root(context_t, Ref) const { ceph_abort("impossible path"); } - virtual node_future lower_bound_tracked( + virtual eagain_future 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; @@ -418,7 +400,7 @@ class Node 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 @@ -430,15 +412,15 @@ class Node }; const parent_info_t& parent_info() const { return *_parent_info; } - node_future<> apply_split_to_parent(context_t, Ref&&, Ref&&, bool); - node_future> get_next_cursor_from_parent(context_t); + eagain_future<> apply_split_to_parent(context_t, Ref&&, Ref&&, bool); + eagain_future> get_next_cursor_from_parent(context_t); template - node_future<> try_merge_adjacent(context_t, bool, Ref&&); - node_future<> erase_node(context_t, Ref&&); + eagain_future<> try_merge_adjacent(context_t, bool, Ref&&); + eagain_future<> erase_node(context_t, Ref&&); template - node_future<> fix_parent_index(context_t, Ref&&, bool); - node_future rebuild_extent(context_t); - node_future<> retire(context_t, Ref&&); + eagain_future<> fix_parent_index(context_t, Ref&&, bool); + eagain_future rebuild_extent(context_t); + eagain_future<> retire(context_t, Ref&&); void make_tail(context_t); private: @@ -457,7 +439,7 @@ class Node std::optional _parent_info; private: - static node_future> load(context_t, laddr_t, bool expect_is_level_tail); + static eagain_future> load(context_t, laddr_t, bool expect_is_level_tail); NodeImplURef impl; friend class InternalNode; @@ -483,9 +465,9 @@ class InternalNode final : public Node { InternalNode& operator=(const InternalNode&) = delete; InternalNode& operator=(InternalNode&&) = delete; - node_future> get_next_cursor(context_t, const search_position_t&); + eagain_future> get_next_cursor(context_t, const search_position_t&); - node_future<> apply_child_split(context_t, Ref&& left, Ref&& right, bool); + eagain_future<> apply_child_split(context_t, Ref&& left, Ref&& right, bool); template void do_track_child(Node& child) { @@ -514,16 +496,16 @@ class InternalNode final : public Node { } } - node_future, Ref>> get_child_peers( + eagain_future, Ref>> get_child_peers( context_t, const search_position_t&); - node_future<> erase_child(context_t, Ref&&); + eagain_future<> erase_child(context_t, Ref&&); template - node_future<> fix_index(context_t, Ref&&, bool); + eagain_future<> fix_index(context_t, Ref&&, bool); template - node_future<> apply_children_merge( + eagain_future<> apply_children_merge( context_t, Ref&& left, laddr_t, Ref&& right, bool update_index); void validate_child_tracked(const Node& child) const { @@ -546,32 +528,32 @@ class InternalNode final : public Node { void track_make_tail(const search_position_t&); - static node_future> allocate_root( + static eagain_future> allocate_root( context_t, level_t, laddr_t, Super::URef&&); protected: - node_future> lookup_smallest(context_t) override; - node_future> lookup_largest(context_t) override; - node_future lower_bound_tracked( + eagain_future> lookup_smallest(context_t) override; + eagain_future> lookup_largest(context_t) override; + eagain_future 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, 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&&); + eagain_future<> try_downgrade_root(context_t, Ref&&); - node_future> insert_or_split( + eagain_future> insert_or_split( context_t, const search_position_t&, const key_view_t&, Ref, Ref outdated_child=nullptr); // XXX: extract a common tracker for InternalNode to track Node, // and LeafNode to track tree_cursor_t. - node_future> get_or_track_child(context_t, const search_position_t&, laddr_t); + eagain_future> get_or_track_child(context_t, const search_position_t&, laddr_t); template void track_insert( const search_position_t&, match_stage_t, Ref, Ref nxt_child = nullptr); @@ -588,7 +570,7 @@ class InternalNode final : public Node { return std::make_pair(Ref(node), mut); } }; - static node_future allocate(context_t, field_type_t, bool, level_t); + static eagain_future allocate(context_t, field_type_t, bool, level_t); private: /** @@ -622,7 +604,7 @@ class LeafNode final : public Node { node_version_t get_version() const; const char* read() const; std::tuple get_kv(const search_position_t&) const; - node_future> get_next_cursor(context_t, const search_position_t&); + eagain_future> get_next_cursor(context_t, const search_position_t&); /** * erase @@ -633,7 +615,7 @@ class LeafNode final : public Node { * pair that followed the erased element, which can be nullptr if is end. */ template - node_future> erase( + eagain_future> erase( context_t, const search_position_t&, bool get_next); template @@ -662,32 +644,32 @@ class LeafNode final : public Node { } } - 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 prepare_mutate_value_payload(context_t); protected: - node_future> lookup_smallest(context_t) override; - node_future> lookup_largest(context_t) override; - node_future lower_bound_tracked( + eagain_future> lookup_smallest(context_t) override; + eagain_future> lookup_largest(context_t) override; + eagain_future 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, 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> insert_value( + eagain_future> insert_value( context_t, const key_hobj_t&, value_config_t, const search_position_t&, const MatchHistory&, match_stat_t mstat); - static node_future> allocate_root(context_t, RootNodeTracker&); + static eagain_future> allocate_root(context_t, RootNodeTracker&); friend class Node; private: @@ -718,7 +700,7 @@ class LeafNode final : public Node { return std::make_pair(Ref(node), mut); } }; - static node_future allocate(context_t, field_type_t, bool); + static eagain_future allocate(context_t, field_type_t, bool); private: /** diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h index 2ac67f5f619c1..37eee930b7709 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h @@ -492,14 +492,13 @@ class NodeExtentAccessorT { std::memcpy(to.get_write(), extent->get_read(), extent->get_length()); } - using ertr = NodeExtentManager::tm_ertr; - ertr::future rebuild(context_t c) { + eagain_future 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(*mut); + return eagain_ertr::make_ready_future(*mut); } assert(!extent->is_initial_pending()); return c.nm.alloc_extent(c.t, node_stage_t::EXTENT_SIZE @@ -551,7 +550,7 @@ class NodeExtentAccessorT { }); } - 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(); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h index d6a651c87b24b..5673db0b4fb72 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h @@ -61,14 +61,6 @@ class NodeExtentManager { 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< diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.cc index 39a94edbb43f0..e8fc618da4498 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.cc @@ -11,7 +11,7 @@ last_split_info_t last_split = {}; #endif // XXX: branchless allocation -InternalNodeImpl::ertr::future +eagain_future InternalNodeImpl::allocate( context_t c, field_type_t type, bool is_level_tail, level_t level) { @@ -28,7 +28,7 @@ InternalNodeImpl::allocate( } } -LeafNodeImpl::ertr::future +eagain_future LeafNodeImpl::allocate( context_t c, field_type_t type, bool is_level_tail) { diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h index 55c8de765aa7e..07cbeffe89b4a 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h @@ -58,13 +58,6 @@ class NodeExtentMutable; */ 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; @@ -96,8 +89,8 @@ class NodeImpl { virtual std::tuple erase(const search_position_t&) = 0; virtual std::tuple evaluate_merge(NodeImpl&) = 0; virtual search_position_t merge(NodeExtentMutable&, NodeImpl&, match_stage_t, node_offset_t) = 0; - virtual ertr::future rebuild_extent(context_t) = 0; - virtual ertr::future<> retire_extent(context_t) = 0; + virtual eagain_future 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; @@ -185,7 +178,7 @@ class InternalNodeImpl : public NodeImpl { return {std::move(impl), mut}; } }; - static ertr::future allocate(context_t, field_type_t, bool, level_t); + static eagain_future allocate(context_t, field_type_t, bool, level_t); static InternalNodeImplURef load(NodeExtentRef, field_type_t, bool); @@ -265,7 +258,7 @@ class LeafNodeImpl : public NodeImpl { return {std::move(impl), mut}; } }; - static ertr::future allocate(context_t, field_type_t, bool); + static eagain_future allocate(context_t, field_type_t, bool); static LeafNodeImplURef load(NodeExtentRef, field_type_t, bool); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h index 873e665e0e31f..33c27cb4ec0e7 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h @@ -66,7 +66,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { return ret; } - static ertr::future allocate( + static eagain_future 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. @@ -267,7 +267,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { return normalize(std::move(left_last_pos)); } - ertr::future + eagain_future rebuild_extent(context_t c) override { return extent.rebuild(c).safe_then([this] (auto mut) { // addr may change @@ -276,7 +276,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl { }); } - ertr::future<> retire_extent(context_t c) override { + eagain_future<> retire_extent(context_t c) override { return extent.retire(c); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h b/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h index 567df2d5ba6ee..17f14dd149b51 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/tree.h @@ -33,15 +33,6 @@ class tree_cursor_t; template 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 - using btree_future = btree_ertr::future; - Btree(NodeExtentManagerURef&& _nm) : nm{std::move(_nm)}, root_tracker{RootNodeTracker::create(nm->is_read_isolated())} {} @@ -52,7 +43,7 @@ class Btree { 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); } @@ -97,7 +88,7 @@ class Btree { 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 get_next(Transaction& t) { + eagain_future get_next(Transaction& t) { assert(!is_end()); auto this_obj = *this; return p_cursor->get_next(p_tree->get_context(t) @@ -111,7 +102,7 @@ class Btree { } template - btree_future erase(Transaction& t) { + eagain_future erase(Transaction& t) { assert(!is_end()); auto this_obj = *this; return p_cursor->erase(p_tree->get_context(t), true @@ -161,7 +152,7 @@ class Btree { * lookup */ - btree_future begin(Transaction& t) { + eagain_future 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) { @@ -169,7 +160,7 @@ class Btree { }); } - btree_future last(Transaction& t) { + eagain_future 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) { @@ -181,10 +172,10 @@ class Btree { return Cursor::make_end(this); } - btree_future contains(Transaction& t, const ghobject_t& obj) { + eagain_future contains(Transaction& t, const ghobject_t& obj) { return seastar::do_with( full_key_t(obj), - [this, &t](auto& key) -> btree_future { + [this, &t](auto& key) -> eagain_future { return get_root(t).safe_then([this, &t, &key](auto root) { // TODO: improve lower_bound() return root->lower_bound(get_context(t), key); @@ -195,10 +186,10 @@ class Btree { ); } - btree_future find(Transaction& t, const ghobject_t& obj) { + eagain_future find(Transaction& t, const ghobject_t& obj) { return seastar::do_with( full_key_t(obj), - [this, &t](auto& key) -> btree_future { + [this, &t](auto& key) -> eagain_future { return get_root(t).safe_then([this, &t, &key](auto root) { // TODO: improve lower_bound() return root->lower_bound(get_context(t), key); @@ -213,10 +204,10 @@ class Btree { ); } - btree_future lower_bound(Transaction& t, const ghobject_t& obj) { + eagain_future lower_bound(Transaction& t, const ghobject_t& obj) { return seastar::do_with( full_key_t(obj), - [this, &t](auto& key) -> btree_future { + [this, &t](auto& key) -> eagain_future { return get_root(t).safe_then([this, &t, &key](auto root) { return root->lower_bound(get_context(t), key); }).safe_then([this](auto result) { @@ -226,7 +217,7 @@ class Btree { ); } - btree_future get_next(Transaction& t, Cursor& cursor) { + eagain_future get_next(Transaction& t, Cursor& cursor) { return cursor.get_next(t); } @@ -237,12 +228,12 @@ class Btree { struct tree_value_config_t { value_size_t payload_size = 256; }; - btree_future> + eagain_future> 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(obj), - [this, &t, vconf](auto& key) -> btree_future> { + [this, &t, vconf](auto& key) -> eagain_future> { 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); @@ -254,10 +245,10 @@ class Btree { ); } - btree_future erase(Transaction& t, const ghobject_t& obj) { + eagain_future erase(Transaction& t, const ghobject_t& obj) { return seastar::do_with( full_key_t(obj), - [this, &t](auto& key) -> btree_future { + [this, &t](auto& key) -> eagain_future { return get_root(t).safe_then([this, &t, &key](auto root) { return root->erase(get_context(t), key); }); @@ -265,11 +256,11 @@ class Btree { ); } - btree_future erase(Transaction& t, Cursor& pos) { + eagain_future 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 @@ -283,19 +274,19 @@ class Btree { * stats */ - btree_future height(Transaction& t) { + eagain_future height(Transaction& t) { return get_root(t).safe_then([](auto root) { return size_t(root->level() + 1); }); } - btree_future get_stats_slow(Transaction& t) { + eagain_future 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(stats); + return seastar::make_ready_future(stats); }); }); } @@ -322,7 +313,7 @@ class Btree { 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 @@ -338,10 +329,10 @@ class Btree { return {*nm, value_builder, t}; } - btree_future> get_root(Transaction& t) { + eagain_future> get_root(Transaction& t) { auto root = root_tracker->get_root(t); if (root) { - return btree_ertr::make_ready_future>(root); + return seastar::make_ready_future>(root); } else { return Node::load_root(get_context(t), *root_tracker); } diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h b/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h index 67c47a68de16f..1f0d284659b58 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h @@ -261,9 +261,6 @@ class TreeBuilder { public: using BtreeImpl = Btree; using BtreeCursor = typename BtreeImpl::Cursor; - using ertr = typename BtreeImpl::btree_ertr; - template - using future = typename ertr::template future; using iterator_t = typename KVPool::iterator_t; TreeBuilder(KVPool& kvs, NodeExtentManagerURef&& nm) @@ -271,7 +268,7 @@ class TreeBuilder { tree.emplace(std::move(nm)); } - future<> bootstrap(Transaction& t) { + eagain_future<> bootstrap(Transaction& t) { std::ostringstream oss; #ifndef NDEBUG oss << "debug=on, "; @@ -293,18 +290,18 @@ class TreeBuilder { return tree->mkfs(t); } - future<> insert(Transaction& t) { + eagain_future<> insert(Transaction& t) { auto ref_kv_iter = seastar::make_lw_shared(); *ref_kv_iter = kvs.random_begin(); auto cursors = seastar::make_lw_shared>(); 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 { + start_time]() -> eagain_future { if (*ref_kv_iter == kvs.random_end()) { std::chrono::duration duration = mono_clock::now() - start_time; logger().warn("Insert done! {}s", duration.count()); - return ertr::template make_ready_future(true); + return seastar::make_ready_future(true); } auto p_kv = **ref_kv_iter; logger().debug("[{}] insert {} -> {}", @@ -330,11 +327,11 @@ class TreeBuilder { 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(false); + return seastar::make_ready_future(false); }); #else ++(*ref_kv_iter); - return ertr::template make_ready_future(false); + return seastar::make_ready_future(false); #endif }); }).safe_then([&t, this, cursors, ref_kv_iter] { @@ -342,11 +339,13 @@ class TreeBuilder { 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 { + 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 { if (*ref_kv_iter == kvs.random_end()) { logger().info("Verify done!"); - return ertr::template make_ready_future(true); + return seastar::make_ready_future(true); } assert(c_iter != cursors->end()); auto p_kv = **ref_kv_iter; @@ -358,33 +357,34 @@ class TreeBuilder { validate_cursor_from_item(p_kv->key, p_kv->value, *c_iter); ++(*ref_kv_iter); ++c_iter; - return ertr::template make_ready_future(false); + return seastar::make_ready_future(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(); auto cursors = seastar::make_lw_shared>(); - 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 { + return crimson::do_until( + [&t, this, cursors, ref_kv_iter, start_time] () -> eagain_future { if (*ref_kv_iter == kvs.end()) { std::chrono::duration duration = mono_clock::now() - start_time; logger().info("Track done! {}s", duration.count()); - return ertr::template make_ready_future(true); + return seastar::make_ready_future(true); } auto p_kv = **ref_kv_iter; return tree->find(t, p_kv->key).safe_then([this, cursors, ref_kv_iter](auto cursor) { @@ -392,22 +392,22 @@ class TreeBuilder { 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(false); + return seastar::make_ready_future(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 { + start_time, begin, end] () -> eagain_future { if (*ref_kv_iter == end) { std::chrono::duration duration = mono_clock::now() - start_time; logger().warn("Erase done! {}s", duration.count()); - return ertr::template make_ready_future(true); + return seastar::make_ready_future(true); } auto p_kv = **ref_kv_iter; logger().debug("[{}] erase {} -> {}", @@ -421,11 +421,11 @@ class TreeBuilder { 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(false); + return seastar::make_ready_future(false); }); #else ++(*ref_kv_iter); - return ertr::template make_ready_future(false); + return seastar::make_ready_future(false); #endif }); }); @@ -456,14 +456,14 @@ class TreeBuilder { }); } - 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 height(Transaction& t) { + eagain_future height(Transaction& t) { return tree->height(t); } @@ -471,7 +471,7 @@ class TreeBuilder { 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) { diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/value.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/value.cc index 1006d5b58bba7..18eebf7182400 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/value.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/value.cc @@ -12,10 +12,6 @@ namespace crimson::os::seastore::onode { -using ertr = Value::ertr; -template -using future = Value::future; - ceph::bufferlist& ValueDeltaRecorder::get_encoded(NodeExtentMutable& payload_mut) { @@ -40,7 +36,7 @@ bool Value::is_tracked() const 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; @@ -53,7 +49,7 @@ future<> Value::extend(Transaction& t, value_size_t 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); diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/value.h b/src/crimson/os/seastore/onode_manager/staged-fltree/value.h index 207e3c58eb898..fe7126f7a9863 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/value.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/value.h @@ -162,15 +162,6 @@ class tree_cursor_t; */ 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 - using future = ertr::future; - virtual ~Value(); Value(const Value&) = default; Value(Value&&) = default; @@ -193,10 +184,10 @@ class Value { Value(NodeExtentManager&, const ValueBuilder&, Ref&); /// 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 diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc index b3762e1d32421..54dab1ca9def8 100644 --- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc +++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc @@ -835,9 +835,9 @@ class DummyChildPool { 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: @@ -868,7 +868,7 @@ class DummyChildPool { ceph_abort("impossible path"); } search_position_t merge(NodeExtentMutable&, NodeImpl&, match_stage_t, node_offset_t) override { ceph_abort("impossible path"); } - ertr::future rebuild_extent(context_t) override { + eagain_future rebuild_extent(context_t) override { ceph_abort("impossible path"); } node_stats_t get_stats() const override { ceph_abort("impossible path"); } @@ -910,7 +910,7 @@ class DummyChildPool { 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>& splitable_nodes) { ceph_assert(can_split()); ceph_assert(splitable_nodes.find(this) != splitable_nodes.end()); @@ -941,7 +941,7 @@ class DummyChildPool { 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>& splitable_nodes) { const auto& keys = impl->get_keys(); @@ -961,7 +961,7 @@ class DummyChildPool { return fut; } - node_future<> merge(context_t c, Ref&& this_ref) { + eagain_future<> merge(context_t c, Ref&& 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; @@ -982,7 +982,7 @@ class DummyChildPool { }); } - 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); @@ -1012,7 +1012,7 @@ class DummyChildPool { return create(keys, is_level_tail, seed++, pool); } - static node_future> create_initial( + static eagain_future> create_initial( context_t c, const std::set& keys, DummyChildPool& pool, RootNodeTracker& root_tracker) { auto initial = create_new(keys, true, pool); @@ -1029,7 +1029,7 @@ class DummyChildPool { } protected: - node_future<> test_clone_non_root( + eagain_future<> test_clone_non_root( context_t, Ref new_parent) const override { ceph_assert(!is_root()); auto p_pool_clone = pool.pool_clone_in_progress; @@ -1037,18 +1037,18 @@ class DummyChildPool { 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> lookup_smallest(context_t) override { + eagain_future> lookup_smallest(context_t) override { ceph_abort("impossible path"); } - node_future> lookup_largest(context_t) override { + eagain_future> 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 lower_bound_tracked( + eagain_future 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, match_stage_t, search_position_t&) override { @@ -1062,7 +1062,7 @@ class DummyChildPool { bool can_split() const { return impl->get_keys().size() > 1; } - static node_future<> do_merge( + static eagain_future<> do_merge( context_t c, Ref&& left, Ref&& right, bool stole_key) { assert(right->use_count() == 1); assert(left->impl->get_keys().size() == 1); @@ -1085,14 +1085,10 @@ class DummyChildPool { }; public: - using node_ertr = Node::node_ertr; - template - using node_future = Node::node_future; - DummyChildPool() = default; ~DummyChildPool() { reset(); } - node_future<> build_tree(const std::set& keys) { + eagain_future<> build_tree(const std::set& keys) { reset(); // create tree @@ -1103,9 +1099,9 @@ class DummyChildPool { ).safe_then([this](auto initial_child) { // split splitable_nodes.insert(initial_child); - return crimson::do_until([this] { + return crimson::do_until([this] () -> eagain_future { if (splitable_nodes.empty()) { - return node_ertr::make_ready_future(true); + return seastar::make_ready_future(true); } auto index = rd() % splitable_nodes.size(); auto iter = splitable_nodes.begin(); @@ -1113,7 +1109,7 @@ class DummyChildPool { Ref child = *iter; return child->populate_split(get_context(), splitable_nodes ).safe_then([] { - return node_ertr::make_ready_future(false); + return seastar::make_ready_future(false); }); }); }).safe_then([this] { -- 2.39.5