From 6ece760c386bea9fa76a4c39f331d073e1c1d101 Mon Sep 17 00:00:00 2001 From: Yingxin Cheng Date: Fri, 16 Apr 2021 13:46:27 +0800 Subject: [PATCH] crimson/onode-staged-tree: test merge in internal node Signed-off-by: Yingxin Cheng --- .../onode_manager/staged-fltree/node.cc | 19 +- .../onode_manager/staged-fltree/node.h | 3 + .../seastore/onode_tree/test_staged_fltree.cc | 242 +++++++++++------- 3 files changed, 170 insertions(+), 94 deletions(-) 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 1e92555de48..a4594b3f5c7 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc @@ -603,6 +603,7 @@ node_future<> Node::erase_node(context_t c, Ref&& this_ref) return parent_info().ptr->erase_child(c, std::move(this_ref)); } +template node_future<> Node::fix_parent_index(context_t c) { assert(!is_root()); @@ -611,8 +612,10 @@ node_future<> Node::fix_parent_index(context_t c) parent->do_untrack_child(*this); // the rest of parent tracks should be correct parent->validate_tracked_children(); - return parent->fix_index(c, this); + return parent->fix_index(c, this); } +template node_future<> Node::fix_parent_index(context_t); +template node_future<> Node::fix_parent_index(context_t); node_future> Node::load( context_t c, laddr_t addr, bool expect_is_level_tail) @@ -887,6 +890,7 @@ node_future<> InternalNode::erase_child(context_t c, Ref&& child_ref) }); } +template node_future<> InternalNode::fix_index(context_t c, Ref child) { impl->validate_non_empty(); @@ -934,12 +938,13 @@ node_future<> InternalNode::fix_index(context_t c, Ref child) } else { // for non-root, maybe need merge adjacent or fix parent, // because the filled node size may be reduced. - return try_merge_adjacent(c, update_parent_index); + return try_merge_adjacent(c, update_parent_index); } } }); } +template node_future<> InternalNode::apply_children_merge( context_t c, Ref&& left_child, Ref&& right_child, bool update_index) @@ -999,7 +1004,7 @@ node_future<> InternalNode::apply_children_merge( left_child = std::move(left_child)] () mutable { Ref this_ref = this; if (update_index) { - return left_child->fix_parent_index(c + return left_child->fix_parent_index(c ).safe_then([c, this, this_ref = std::move(this_ref)] { // I'm all good but: // - my number of keys is reduced by 1 @@ -1020,11 +1025,15 @@ node_future<> InternalNode::apply_children_merge( if (is_root()) { return try_downgrade_root(c, std::move(this_ref)); } else { - return try_merge_adjacent(c, false); + return try_merge_adjacent(c, false); } } }); } +template node_future<> InternalNode::apply_children_merge( + context_t, Ref&&, Ref&&, bool); +template node_future<> InternalNode::apply_children_merge( + context_t, Ref&&, Ref&&, bool); node_future, Ref>> InternalNode::get_child_peers( context_t c, const search_position_t& pos) @@ -1522,6 +1531,8 @@ void InternalNode::track_erase( p_node->as_child(new_pos, this); } } +template void InternalNode::track_erase(const search_position_t&, match_stage_t); +template void InternalNode::track_erase(const search_position_t&, match_stage_t); void InternalNode::track_make_tail(const search_position_t& last_pos) { 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 0cb6c2289fb..94f1062d02a 100644 --- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.h +++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.h @@ -435,6 +435,7 @@ class Node template node_future<> try_merge_adjacent(context_t, bool); node_future<> erase_node(context_t, Ref&&); + template node_future<> fix_parent_index(context_t); node_future rebuild_extent(context_t); node_future<> retire(context_t, Ref&&); @@ -518,8 +519,10 @@ class InternalNode final : public Node { node_future<> erase_child(context_t, Ref&&); + template node_future<> fix_index(context_t, Ref); + template node_future<> apply_children_merge( context_t, Ref&& left, Ref&& right, bool update_index); 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 3b8d53eb3c1..cf5573ce93e 100644 --- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc +++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc @@ -829,13 +829,17 @@ class DummyChildPool { laddr_t laddr() const override { return _laddr; } bool is_level_tail() const override { return _is_level_tail; } std::optional get_pivot_index() const override { return {key_view}; } - bool is_extent_valid() const override { return true; } + bool is_extent_valid() const override { return _is_extent_valid; } const std::string& get_name() const override { return name; } search_position_t make_tail() override { _is_level_tail = true; build_name(); return search_position_t::end(); } + ertr::future<> retire_extent(context_t) override { + _is_extent_valid = false; + return ertr::now(); + } protected: node_type_t node_type() const override { return node_type_t::LEAF; } @@ -867,8 +871,6 @@ class DummyChildPool { ceph_abort("impossible path"); } ertr::future rebuild_extent(context_t) override { ceph_abort("impossible path"); } - ertr::future<> retire_extent(context_t) override { - ceph_abort("impossible path"); } node_stats_t get_stats() const override { ceph_abort("impossible path"); } std::ostream& dump(std::ostream&) const override { @@ -897,6 +899,7 @@ class DummyChildPool { bool _is_level_tail; laddr_t _laddr; std::string name; + bool _is_extent_valid = true; key_view_t key_view; void* p_mem_key_view; @@ -906,6 +909,8 @@ class DummyChildPool { public: ~DummyChild() override = default; + key_view_t get_pivot_key() const { return *impl->get_pivot_index(); } + node_future<> populate_split( context_t c, std::set>& splitable_nodes) { ceph_assert(can_split()); @@ -955,6 +960,27 @@ class DummyChildPool { return fut; } + node_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; + if (rnode) { + lnode.reset(); + Ref r_dummy(static_cast(rnode.get())); + rnode.reset(); + pool.untrack_node(r_dummy); + assert(r_dummy->use_count() == 1); + return do_merge(c, std::move(this_ref), std::move(r_dummy), true); + } else { + ceph_assert(lnode); + Ref l_dummy(static_cast(lnode.get())); + pool.untrack_node(this_ref); + assert(this_ref->use_count() == 1); + return do_merge(c, std::move(l_dummy), std::move(this_ref), false); + } + }); + } + bool match_pos(const search_position_t& pos) const { ceph_assert(!is_root()); return pos == parent_info().position; @@ -1008,8 +1034,7 @@ class DummyChildPool { ceph_abort("impossible path"); } node_future<> do_get_tree_stats(context_t, tree_stats_t&) override { ceph_abort("impossible path"); } - bool is_tracking() const override { - ceph_abort("impossible path"); } + bool is_tracking() const override { return false; } void track_merge(Ref, match_stage_t, search_position_t&) override { ceph_abort("impossible path"); } @@ -1021,6 +1046,23 @@ class DummyChildPool { bool can_split() const { return impl->get_keys().size() > 1; } + static node_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); + assert(right->impl->get_keys().size() == 1); + bool left_is_tail = right->impl->is_level_tail(); + const std::set* p_keys; + if (stole_key) { + p_keys = &right->impl->get_keys(); + } else { + p_keys = &left->impl->get_keys(); + } + left->impl->reset(*p_keys, left_is_tail); + return left->parent_info().ptr->apply_children_merge( + c, std::move(left), std::move(right), !stole_key); + } + DummyChildImpl* impl; DummyChildPool& pool; mutable std::random_device rd; @@ -1038,9 +1080,9 @@ class DummyChildPool { reset(); // create tree - auto ref_nm = NodeExtentManager::create_dummy(IS_DUMMY_SYNC); - p_nm = ref_nm.get(); - p_btree.emplace(std::move(ref_nm)); + auto ref_dummy = NodeExtentManager::create_dummy(IS_DUMMY_SYNC); + p_dummy = static_cast(ref_dummy.get()); + p_btree.emplace(std::move(ref_dummy)); return DummyChild::create_initial(get_context(), keys, *this, *p_btree->root_tracker ).safe_then([this](auto initial_child) { // split @@ -1068,26 +1110,41 @@ class DummyChildPool { }); } - seastar::future<> test_split(ghobject_t key, search_position_t pos, - const split_expectation_t& expected) { + seastar::future<> split_merge(ghobject_t key, search_position_t pos, + const split_expectation_t& expected) { return seastar::async([this, key, pos, expected] { - logger().info("insert {} at {}:", key_hobj_t(key), pos); + // clone DummyChildPool pool_clone; pool_clone_in_progress = &pool_clone; - auto ref_nm = NodeExtentManager::create_dummy(IS_DUMMY_SYNC); - pool_clone.p_nm = ref_nm.get(); - pool_clone.p_btree.emplace(std::move(ref_nm)); + auto ref_dummy = NodeExtentManager::create_dummy(IS_DUMMY_SYNC); + pool_clone.p_dummy = static_cast(ref_dummy.get()); + pool_clone.p_btree.emplace(std::move(ref_dummy)); pool_clone.p_btree->test_clone_from( pool_clone.t(), t(), *p_btree).unsafe_get0(); pool_clone_in_progress = nullptr; + + // insert and split + logger().info("\n\nINSERT-SPLIT {} at pos({}):", key_hobj_t(key), pos); auto node_to_split = pool_clone.get_node_by_pos(pos); node_to_split->insert_and_split( pool_clone.get_context(), key, pool_clone.splitable_nodes).unsafe_get0(); - std::ostringstream oss; - pool_clone.p_btree->dump(pool_clone.t(), oss); - logger().info("dump new root:\n{}", oss.str()); + { + std::ostringstream oss; + pool_clone.p_btree->dump(pool_clone.t(), oss); + logger().info("dump new root:\n{}", oss.str()); + } EXPECT_EQ(pool_clone.p_btree->height(pool_clone.t()).unsafe_get0(), 3); EXPECT_TRUE(last_split.match(expected)); + EXPECT_EQ(pool_clone.p_dummy->size(), 3); + + // erase and merge + auto pivot_key = node_to_split->get_pivot_key(); + logger().info("\n\nERASE-MERGE {}:", node_to_split->get_name()); + assert(pivot_key.compare_to(key_hobj_t(key)) == MatchKindCMP::EQ); + node_to_split->merge( + pool_clone.get_context(), std::move(node_to_split)).unsafe_get0(); + EXPECT_EQ(pool_clone.p_btree->height(pool_clone.t()).unsafe_get0(), 2); + EXPECT_EQ(pool_clone.p_dummy->size(), 1); }); } @@ -1098,7 +1155,7 @@ class DummyChildPool { ceph_assert(!p_btree->test_is_clean()); tracked_children.clear(); ceph_assert(p_btree->test_is_clean()); - p_nm = nullptr; + p_dummy = nullptr; p_btree.reset(); } else { ceph_assert(!p_btree.has_value()); @@ -1111,6 +1168,11 @@ class DummyChildPool { tracked_children.insert(node); } + void untrack_node(Ref node) { + auto ret = tracked_children.erase(node); + ceph_assert(ret == 1); + } + Ref get_node_by_pos(const search_position_t& pos) const { auto iter = std::find_if( tracked_children.begin(), tracked_children.end(), [&pos](auto& child) { @@ -1121,15 +1183,15 @@ class DummyChildPool { } context_t get_context() { - ceph_assert(p_nm != nullptr); - return {*p_nm, vb, t()}; + ceph_assert(p_dummy != nullptr); + return {*p_dummy, vb, t()}; } Transaction& t() const { return *ref_t; } std::set> tracked_children; std::optional p_btree; - NodeExtentManager* p_nm = nullptr; + DummyManager* p_dummy = nullptr; ValueBuilderImpl vb; TransactionRef ref_t = make_test_transaction(); @@ -1141,7 +1203,7 @@ class DummyChildPool { } -TEST_F(c_dummy_test_t, 5_split_internal_node) +TEST_F(c_dummy_test_t, 5_split_merge_internal_node) { run_async([this] { DummyChildPool pool; @@ -1168,65 +1230,65 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to right front at stage 0, 1, 2, 1, 0\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 5, 5), {2, {0, {0}}}, - {2u, 0u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), {2, {0, {0}}}, - {2u, 1u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(3, 4, 4, "ns3", "oid3", 3, 3), {2, {0, {0}}}, - {2u, 2u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(4, 4, 4, "ns1", "oid1", 3, 3), {2, {0, {0}}}, - {2u, 1u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(4, 4, 4, "ns2", "oid2" + padding, 1, 1), {2, {0, {0}}}, - {2u, 0u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 5, 5), {2, {0, {0}}}, + {2u, 0u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), {2, {0, {0}}}, + {2u, 1u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 4, 4, "ns3", "oid3", 3, 3), {2, {0, {0}}}, + {2u, 2u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "ns1", "oid1", 3, 3), {2, {0, {0}}}, + {2u, 1u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "ns2", "oid2" + padding, 1, 1), {2, {0, {0}}}, + {2u, 0u, false, InsertType::BEGIN}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to right middle at stage 0, 1, 2, 1, 0\n"); - pool.test_split(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 5, 5), {3, {0, {0}}}, - {2u, 0u, false, InsertType::MID}).get(); - pool.test_split(make_ghobj(4, 4, 4, "ns5", "oid5", 3, 3), {3, {0, {0}}}, - {2u, 1u, false, InsertType::MID}).get(); - pool.test_split(make_ghobj(4, 4, 5, "ns3", "oid3", 3, 3), {3, {0, {0}}}, - {2u, 2u, false, InsertType::MID}).get(); - pool.test_split(make_ghobj(5, 5, 5, "ns1", "oid1", 3, 3), {3, {0, {0}}}, - {2u, 1u, false, InsertType::MID}).get(); - pool.test_split(make_ghobj(5, 5, 5, "ns2", "oid2" + padding, 1, 1), {3, {0, {0}}}, - {2u, 0u, false, InsertType::MID}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 5, 5), {3, {0, {0}}}, + {2u, 0u, false, InsertType::MID}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "ns5", "oid5", 3, 3), {3, {0, {0}}}, + {2u, 1u, false, InsertType::MID}).get(); + pool.split_merge(make_ghobj(4, 4, 5, "ns3", "oid3", 3, 3), {3, {0, {0}}}, + {2u, 2u, false, InsertType::MID}).get(); + pool.split_merge(make_ghobj(5, 5, 5, "ns1", "oid1", 3, 3), {3, {0, {0}}}, + {2u, 1u, false, InsertType::MID}).get(); + pool.split_merge(make_ghobj(5, 5, 5, "ns2", "oid2" + padding, 1, 1), {3, {0, {0}}}, + {2u, 0u, false, InsertType::MID}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to right back at stage 0, 1, 2\n"); - pool.test_split(make_ghobj(5, 5, 5, "ns4", "oid4" + padding_e, 5, 5), search_position_t::end(), + pool.split_merge(make_ghobj(5, 5, 5, "ns4", "oid4" + padding_e, 5, 5), search_position_t::end() , {2u, 0u, false, InsertType::LAST}).get(); - pool.test_split(make_ghobj(5, 5, 5, "ns5", "oid5", 3, 3), search_position_t::end(), - {2u, 1u, false, InsertType::LAST}).get(); - pool.test_split(make_ghobj(6, 6, 6, "ns3", "oid3", 3, 3), search_position_t::end(), - {2u, 2u, false, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(5, 5, 5, "ns5", "oid5", 3, 3), search_position_t::end(), + {2u, 1u, false, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(6, 6, 6, "ns3", "oid3", 3, 3), search_position_t::end(), + {2u, 2u, false, InsertType::LAST}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 0; insert to left front at stage 2, 1, 0\n"); - pool.test_split(make_ghobj(1, 1, 1, "ns3", "oid3", 3, 3), {0, {0, {0}}}, - {0u, 2u, true, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(2, 2, 2, "ns1", "oid1", 3, 3), {0, {0, {0}}}, - {0u, 1u, true, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(2, 2, 2, "ns2", "oid2" + padding_s, 1, 1), {0, {0, {0}}}, - {0u, 0u, true, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(1, 1, 1, "ns3", "oid3", 3, 3), {0, {0, {0}}}, + {0u, 2u, true, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(2, 2, 2, "ns1", "oid1", 3, 3), {0, {0, {0}}}, + {0u, 1u, true, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(2, 2, 2, "ns2", "oid2" + padding_s, 1, 1), {0, {0, {0}}}, + {0u, 0u, true, InsertType::BEGIN}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 0; insert to left middle at stage 0, 1, 2, 1, 0\n"); - pool.test_split(make_ghobj(2, 2, 2, "ns4", "oid4" + padding, 5, 5), {1, {0, {0}}}, - {0u, 0u, true, InsertType::MID}).get(); - pool.test_split(make_ghobj(2, 2, 2, "ns5", "oid5", 3, 3), {1, {0, {0}}}, - {0u, 1u, true, InsertType::MID}).get(); - pool.test_split(make_ghobj(2, 2, 3, "ns3", "oid3" + std::string(80, '_'), 3, 3), {1, {0, {0}}}, + pool.split_merge(make_ghobj(2, 2, 2, "ns4", "oid4" + padding, 5, 5), {1, {0, {0}}}, + {0u, 0u, true, InsertType::MID}).get(); + pool.split_merge(make_ghobj(2, 2, 2, "ns5", "oid5", 3, 3), {1, {0, {0}}}, + {0u, 1u, true, InsertType::MID}).get(); + pool.split_merge(make_ghobj(2, 2, 3, "ns3", "oid3" + std::string(80, '_'), 3, 3), {1, {0, {0}}} , {0u, 2u, true, InsertType::MID}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns1", "oid1", 3, 3), {1, {0, {0}}}, - {0u, 1u, true, InsertType::MID}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 1, 1), {1, {0, {0}}}, - {0u, 0u, true, InsertType::MID}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns1", "oid1", 3, 3), {1, {0, {0}}}, + {0u, 1u, true, InsertType::MID}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 1, 1), {1, {0, {0}}}, + {0u, 0u, true, InsertType::MID}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 0; insert to left back at stage 0\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 3, 4), {1, {2, {2}}}, - {0u, 0u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 3, 4), {1, {2, {2}}}, + {0u, 0u, true, InsertType::LAST}).get(); } { @@ -1241,19 +1303,19 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to left back at stage 0, 1, 2, 1\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 5, 5), {2, {0, {0}}}, - {2u, 0u, true, InsertType::LAST}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), {2, {0, {0}}}, - {2u, 1u, true, InsertType::LAST}).get(); - pool.test_split(make_ghobj(3, 4, 4, "n", "o", 3, 3), {2, {0, {0}}}, - {2u, 2u, true, InsertType::LAST}).get(); - pool.test_split(make_ghobj(4, 4, 4, "n", "o", 3, 3), {2, {0, {0}}}, - {2u, 1u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4" + padding, 5, 5), {2, {0, {0}}}, + {2u, 0u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), {2, {0, {0}}}, + {2u, 1u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 4, 4, "n", "o", 3, 3), {2, {0, {0}}}, + {2u, 2u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "n", "o", 3, 3), {2, {0, {0}}}, + {2u, 1u, true, InsertType::LAST}).get(); logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to left middle at stage 2\n"); - pool.test_split(make_ghobj(2, 3, 3, "n", "o", 3, 3), {1, {0, {0}}}, - {2u, 2u, true, InsertType::MID}).get(); + pool.split_merge(make_ghobj(2, 3, 3, "n", "o", 3, 3), {1, {0, {0}}}, + {2u, 2u, true, InsertType::MID}).get(); } { @@ -1268,8 +1330,8 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 2; insert to left back at stage (0, 1, 2, 1,) 0\n"); - pool.test_split(make_ghobj(4, 4, 4, "n", "o", 2, 2), {2, {0, {0}}}, - {2u, 0u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(4, 4, 4, "n", "o", 2, 2), {2, {0, {0}}}, + {2u, 0u, true, InsertType::LAST}).get(); } { @@ -1284,12 +1346,12 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 1; insert to right front at stage 0, 1, 0\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 5, 5), {1, {1, {0}}}, - {1u, 0u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid3", 3, 3), {1, {1, {0}}}, - {1u, 1u, false, InsertType::BEGIN}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns3", "oid3" + padding, 1, 1), {1, {1, {0}}}, - {1u, 0u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 5, 5), {1, {1, {0}}}, + {1u, 0u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid3", 3, 3), {1, {1, {0}}}, + {1u, 1u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns3", "oid3" + padding, 1, 1), {1, {1, {0}}}, + {1u, 0u, false, InsertType::BEGIN}).get(); } { @@ -1308,10 +1370,10 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 1; insert to left back at stage 0, 1\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 5, 5), {1, {1, {0}}}, - {1u, 0u, true, InsertType::LAST}).get(); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid3", 3, 3), {1, {1, {0}}}, - {1u, 1u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2" + padding, 5, 5), {1, {1, {0}}}, + {1u, 0u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid3", 3, 3), {1, {1, {0}}}, + {1u, 1u, true, InsertType::LAST}).get(); } { @@ -1329,8 +1391,8 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 1; insert to left back at stage (0, 1,) 0\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns2", "oid3", 2, 2), {1, {1, {0}}}, - {1u, 0u, true, InsertType::LAST}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns2", "oid3", 2, 2), {1, {1, {0}}}, + {1u, 0u, true, InsertType::LAST}).get(); } { @@ -1344,8 +1406,8 @@ TEST_F(c_dummy_test_t, 5_split_internal_node) logger().info("\n---------------------------------------------" "\nsplit at stage 0; insert to right front at stage 0\n"); - pool.test_split(make_ghobj(3, 3, 3, "ns3", "oid3" + padding, 2, 3), {1, {1, {1}}}, - {0u, 0u, false, InsertType::BEGIN}).get(); + pool.split_merge(make_ghobj(3, 3, 3, "ns3", "oid3" + padding, 2, 3), {1, {1, {1}}}, + {0u, 0u, false, InsertType::BEGIN}).get(); } // Impossible to split at {0, 0, 0} -- 2.39.5