crimson/onode-staged-tree: clean up insert/split logs

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>

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 1fe1997315b914185c9648ca6efd47c1c32df07e..bd72c8f33d2997c5e61a11fe57dc29039f774dee 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
@@ -260,14 +260,25 @@ node_future<> InternalNode::apply_child_split(
 #endif
   impl->prepare_mutate(c);
 
-  // update pos => left_child to pos => right_child
+  auto left_key = left_child->impl->get_largest_key_view();
   auto left_child_addr = left_child->impl->laddr();
   auto left_child_addr_packed = laddr_packed_t{left_child_addr};
+  auto right_key = right_child->impl->get_largest_key_view();
   auto right_child_addr = right_child->impl->laddr();
+  std::cout << "internal insert at pos(" << pos << "), "
+            << "left-child[" << left_key << ", 0x"
+            << std::hex << left_child_addr << std::dec
+            << "], right-child[" << right_key << ", 0x" <<
+            std::hex << right_child_addr << std::dec << "]" << std::endl;
+#if 0
+  std::cout << "before insert:" << std::endl;
+  dump(std::cout) << std::endl;
+#endif
+
+  // update pos => left_child to pos => right_child
   impl->replace_child_addr(pos, right_child_addr, left_child_addr);
   replace_track(pos, right_child, left_child);
 
-  auto left_key = left_child->impl->get_largest_key_view();
   search_position_t insert_pos = pos;
   auto [insert_stage, insert_size] = impl->evaluate_insert(
       left_key, left_child_addr, insert_pos);
@@ -284,11 +295,6 @@ node_future<> InternalNode::apply_child_split(
     return node_ertr::now();
   }
   // split and insert
-  std::cout << "  try insert at: " << insert_pos
-            << ", insert_stage=" << (int)insert_stage
-            << ", insert_size=" << insert_size
-            << ", values=0x" << std::hex << left_child_addr
-            << ",0x" << right_child_addr << std::dec << std::endl;
   Ref<InternalNode> this_ref = this;
   return (is_root() ? upgrade_root(c) : node_ertr::now()
   ).safe_then([this, c] {
@@ -586,6 +592,12 @@ node_future<Ref<tree_cursor_t>> LeafNode::insert_value(
     assert(impl->is_level_tail());
   }
 #endif
+  std::cout << "leaf insert at pos(" << pos << "), "
+            << key << ", " << value << std::endl;
+#if 0
+  std::cout << "before insert:" << std::endl;
+  dump(std::cout) << std::endl;
+#endif
 
   search_position_t insert_pos = pos;
   auto [insert_stage, insert_size] = impl->evaluate_insert(
@@ -604,10 +616,6 @@ node_future<Ref<tree_cursor_t>> LeafNode::insert_value(
     return node_ertr::make_ready_future<Ref<tree_cursor_t>>(ret);
   }
   // split and insert
-  std::cout << "  try insert at: " << insert_pos
-            << ", insert_stage=" << (int)insert_stage
-            << ", insert_size=" << insert_size
-            << std::endl;
   Ref<LeafNode> this_ref = this;
   return (is_root() ? upgrade_root(c) : node_ertr::now()
   ).safe_then([this, c] {

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 0c6e478807dc01e74531a5a02e0b480087db2181..d5aef9ad95864d37780dc6ff08582ff760609cd1 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
@@ -243,8 +243,18 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       const full_key_t<KEY_TYPE>& key, const value_t& value,
       search_position_t& insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
+    std::cout << "INSERT start: insert_pos(" << insert_pos
+              << "), insert_stage=" << (int)insert_stage
+              << ", insert_size=" << insert_size << " ..." << std::endl;
     auto ret = extent.template insert_replayable<KEY_TYPE>(
         key, value, cast_down<STAGE>(insert_pos), insert_stage, insert_size);
+#if 0
+    dump(std::cout) << std::endl;
+#endif
+    std::cout << "INSERT done: insert_pos(" << insert_pos
+              << "), insert_stage=" << (int)insert_stage
+              << ", insert_size=" << insert_size
+              << std::endl << std::endl;
     assert(get_key_view(insert_pos) == key);
     return ret;
   }
@@ -254,20 +264,36 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       const full_key_t<KEY_TYPE>& key, const value_t& value,
       search_position_t& _insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
+    std::cout << "SPLIT-INSERT start: insert_pos(" << _insert_pos
+              << "), insert_stage=" << (int)insert_stage
+              << ", insert_size=" << insert_size
+              << std::endl;
     auto& insert_pos = cast_down<STAGE>(_insert_pos);
     auto& node_stage = extent.read();
-    size_t empty_size = node_stage.size_before(0);
-    size_t available_size = node_stage.total_size() - empty_size;
-    size_t target_split_size = empty_size + (available_size + insert_size) / 2;
-    // TODO adjust NODE_BLOCK_SIZE according to this requirement
-    assert(insert_size < available_size / 2);
     typename STAGE_T::StagedIterator split_at;
-    bool is_insert_left = STAGE_T::locate_split(
-        node_stage, target_split_size, insert_pos, insert_stage, insert_size, split_at);
-
-    std::cout << "  split at: " << split_at << ", is_insert_left=" << is_insert_left
-              << ", now insert at: " << insert_pos
-              << std::endl;
+    bool is_insert_left;
+    {
+      size_t empty_size = node_stage.size_before(0);
+      size_t available_size = node_stage.total_size() - empty_size;
+      size_t target_split_size = empty_size + (available_size + insert_size) / 2;
+      // TODO adjust NODE_BLOCK_SIZE according to this requirement
+      assert(insert_size < available_size / 2);
+
+      size_t split_size = 0;
+      std::optional<bool> _is_insert_left;
+      split_at.set(node_stage);
+      STAGE_T::recursively_locate_split_inserted(
+          split_size, 0, target_split_size, insert_pos,
+          insert_stage, insert_size, _is_insert_left, split_at);
+      is_insert_left = *_is_insert_left;
+      std::cout << "located_split: split_at(" << split_at << "), insert_pos(" << insert_pos
+                << "), is_insert_left=" << is_insert_left
+                << ", estimated_split_size=" << split_size
+                << "(target=" << target_split_size
+                << ", current=" << node_stage.size_before(node_stage.keys())
+                << ")" << std::endl;
+      assert(split_size <= target_split_size);
+    }
 
     auto append_at = split_at;
     // TODO(cross-node string dedup)
@@ -278,14 +304,17 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       // right node: append [start(append_at), insert_pos)
       STAGE_T::template append_until<KEY_TYPE>(
           append_at, right_appender, insert_pos, insert_stage);
-      std::cout << "insert to right: " << insert_pos
-                << ", insert_stage=" << (int)insert_stage << std::endl;
+      std::cout << "append-insert right: insert_pos(" << insert_pos
+                << "), insert_stage=" << (int)insert_stage
+                << " ..." << std::endl;
       // right node: append [insert_pos(key, value)]
       bool is_front_insert = (insert_pos == position_t::begin());
       bool is_end = STAGE_T::template append_insert<KEY_TYPE>(
           key, value, append_at, right_appender,
           is_front_insert, insert_stage, p_value);
       assert(append_at.is_end() == is_end);
+    } else {
+      std::cout << "append right ..." << std::endl;
     }
 
     // right node: append (insert_pos, end)
@@ -298,10 +327,14 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
 
     // mutate left node
     if (is_insert_left) {
+      std::cout << "trim-insert left: insert_pos(" << insert_pos
+                << "), insert_stage=" << (int)insert_stage
+                << " ..." << std::endl;
       p_value = extent.template split_insert_replayable<KEY_TYPE>(
           split_at, key, value, insert_pos, insert_stage, insert_size);
       assert(get_key_view(_insert_pos) == key);
     } else {
+      std::cout << "trim left ..." << std::endl;
       assert(right_impl.get_key_view(_insert_pos) == key);
       extent.split_replayable(split_at);
     }
@@ -309,10 +342,11 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
     assert(p_value);
 
     auto split_pos = normalize(split_at.get_pos());
-    std::cout << "split at " << split_pos
-              << ", insert at " << _insert_pos
-              << ", is_insert_left=" << is_insert_left
-              << ", insert_stage=" << (int)insert_stage << std::endl;
+    std::cout << "SPLIT-INSERT done: split_pos(" << split_pos
+              << "), insert_pos(" << _insert_pos
+              << "), insert_stage=" << (int)insert_stage
+              << ", insert_size=" << insert_size
+              << std::endl << std::endl;
     return {split_pos, is_insert_left, p_value};
   }
 

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h
index 398e2f66f1cf07a8992e8fa652793708e92c7ee5..158094cbec4aaab037c4b3c3693e3db82869b989 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout_replayable.h
@@ -56,8 +56,6 @@ struct NodeLayoutReplayableT {
       node_offset_t& insert_size) {
     node_stage_t::update_is_level_tail(mut, node_stage, false);
     STAGE_T::trim(mut, split_at);
-    std::cout << "insert to left: " << insert_pos
-              << ", insert_stage=" << (int)insert_stage << std::endl;
     auto p_value = STAGE_T::template proceed_insert<KT, true>(
         mut, node_stage, key, value, insert_pos, insert_stage, insert_size);
     return p_value;

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h
index cc57d432ccc3b359c4fae70a81a5a3f21a899ad3..2a647970602f6e2d16bd86e3664f26724a553cd1 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage.h
@@ -6,8 +6,6 @@
 #include <cassert>
 #include <optional>
 #include <ostream>
-// TODO: remove
-#include <iostream>
 #include <sstream>
 #include <type_traits>
 
@@ -1444,24 +1442,6 @@ struct staged {
     return;
   }
 
-  static bool locate_split(
-      const container_t& container, size_t target_size,
-      position_t& i_position, match_stage_t i_stage, size_t i_size,
-      StagedIterator& split_at) {
-    split_at.set(container);
-    size_t current_size = 0;
-    std::optional<bool> i_to_left;
-    recursively_locate_split_inserted(
-        current_size, 0, target_size,
-        i_position, i_stage, i_size, i_to_left, split_at);
-    std::cout << "  locate_split(): size_to_left=" << current_size
-              << ", target_split_size=" << target_size
-              << ", original_size=" << container.size_before(container.keys())
-              << std::endl;
-    assert(current_size <= target_size);
-    return *i_to_left;
-  }
-
   /*
    * container appender type system
    *   container_t::Appender(NodeExtentMutable& mut, char* p_append)