crimson/onode-staged-tree: introduce value_input_t

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 7c5e5a34345a681c9332a2ee1c4b0f08cf8a2aa5..3926b0f30b11644e623504fd0a83ab416d096ed3 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
@@ -296,7 +296,6 @@ node_future<> InternalNode::apply_child_split(
 
   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();
   logger().debug("OTree::Internal::Insert: "
@@ -313,7 +312,7 @@ node_future<> InternalNode::apply_child_split(
   if (free_size >= insert_size) {
     // insert
     [[maybe_unused]] auto p_value = impl->insert(
-        left_key, left_child_addr_packed, insert_pos, insert_stage, insert_size);
+        left_key, left_child_addr, insert_pos, insert_stage, insert_size);
     assert(impl->free_size() == free_size - insert_size);
     assert(insert_pos <= pos);
     assert(p_value->value == left_child_addr);
@@ -331,9 +330,8 @@ node_future<> InternalNode::apply_child_split(
                 insert_pos, insert_stage=insert_stage, insert_size=insert_size](auto fresh_right) mutable {
     auto right_node = fresh_right.node;
     auto left_child_addr = left_child->impl->laddr();
-    auto left_child_addr_packed = laddr_packed_t{left_child_addr};
     auto [split_pos, is_insert_left, p_value] = impl->split_insert(
-        fresh_right.mut, *right_node->impl, left_key, left_child_addr_packed,
+        fresh_right.mut, *right_node->impl, left_key, left_child_addr,
         insert_pos, insert_stage, insert_size);
     assert(p_value->value == left_child_addr);
     track_split(split_pos, right_node);

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 33021813ece020500861cd007287a48abd98dd7e..f22de27b2295d9ee9e9b99e983e60141db57ea44 100644 (file)
--- 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
@@ -27,7 +27,7 @@ class DeltaRecorderT final: public DeltaRecorder {
   using node_stage_t = typename layout_t::node_stage_t;
   using position_t = typename layout_t::position_t;
   using StagedIterator = typename layout_t::StagedIterator;
-  using value_t = typename layout_t::value_t;
+  using value_input_t = typename layout_t::value_input_t;
   static constexpr auto FIELD_TYPE = layout_t::FIELD_TYPE;
 
   ~DeltaRecorderT() override = default;
@@ -35,7 +35,7 @@ class DeltaRecorderT final: public DeltaRecorder {
   template <KeyT KT>
   void encode_insert(
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       const position_t& insert_pos,
       const match_stage_t& insert_stage,
       const node_offset_t& insert_size) {
@@ -58,7 +58,7 @@ class DeltaRecorderT final: public DeltaRecorder {
   void encode_split_insert(
       const StagedIterator& split_at,
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       const position_t& insert_pos,
       const match_stage_t& insert_stage,
       const node_offset_t& insert_size,
@@ -105,7 +105,7 @@ class DeltaRecorderT final: public DeltaRecorder {
         auto key = key_hobj_t::decode(delta);
 
         std::unique_ptr<char[]> value_storage_heap;
-        value_t value_storage_stack;
+        value_input_t value_storage_stack;
         auto p_value = decode_value(delta, value_storage_heap, value_storage_stack);
 
         auto insert_pos = position_t::decode(delta);
@@ -133,7 +133,7 @@ class DeltaRecorderT final: public DeltaRecorder {
         auto key = key_hobj_t::decode(delta);
 
         std::unique_ptr<char[]> value_storage_heap;
-        value_t value_storage_stack;
+        value_input_t value_storage_stack;
         auto p_value = decode_value(delta, value_storage_heap, value_storage_stack);
 
         auto insert_pos = position_t::decode(delta);
@@ -174,11 +174,11 @@ class DeltaRecorderT final: public DeltaRecorder {
   }
 
  private:
-  static void encode_value(const value_t& value, ceph::bufferlist& encoded) {
-    if constexpr (std::is_same_v<value_t, laddr_packed_t>) {
+  static void encode_value(const value_input_t& value, ceph::bufferlist& encoded) {
+    if constexpr (std::is_same_v<value_input_t, laddr_t>) {
       // NODE_TYPE == node_type_t::INTERNAL
-      ceph::encode(value.value, encoded);
-    } else if constexpr (std::is_same_v<value_t, onode_t>) {
+      ceph::encode(value, encoded);
+    } else if constexpr (std::is_same_v<value_input_t, onode_t>) {
       // NODE_TYPE == node_type_t::LEAF
       value.encode(encoded);
     } else {
@@ -186,16 +186,16 @@ class DeltaRecorderT final: public DeltaRecorder {
     }
   }
 
-  static value_t* decode_value(ceph::bufferlist::const_iterator& delta,
-                               std::unique_ptr<char[]>& value_storage_heap,
-                               value_t& value_storage_stack) {
-    if constexpr (std::is_same_v<value_t, laddr_packed_t>) {
+  static value_input_t* decode_value(ceph::bufferlist::const_iterator& delta,
+                                     std::unique_ptr<char[]>& value_storage_heap,
+                                     value_input_t& value_storage_stack) {
+    if constexpr (std::is_same_v<value_input_t, laddr_t>) {
       // NODE_TYPE == node_type_t::INTERNAL
       laddr_t value;
       ceph::decode(value, delta);
-      value_storage_stack.value = value;
+      value_storage_stack = value;
       return &value_storage_stack;
-    } else if constexpr (std::is_same_v<value_t, onode_t>) {
+    } else if constexpr (std::is_same_v<value_input_t, onode_t>) {
       // NODE_TYPE == node_type_t::LEAF
       auto value_config = onode_t::decode(delta);
       value_storage_heap = onode_t::allocate(value_config);
@@ -225,6 +225,7 @@ class NodeExtentAccessorT {
   using position_t = typename layout_t::position_t;
   using recorder_t = DeltaRecorderT<FieldType, NODE_TYPE>;
   using StagedIterator = typename layout_t::StagedIterator;
+  using value_input_t = typename layout_t::value_input_t;
   using value_t = typename layout_t::value_t;
   static constexpr auto FIELD_TYPE = layout_t::FIELD_TYPE;
 
@@ -284,7 +285,7 @@ class NodeExtentAccessorT {
   template <KeyT KT>
   const value_t* insert_replayable(
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       position_t& insert_pos,
       match_stage_t& insert_stage,
       node_offset_t& insert_size) {
@@ -326,7 +327,7 @@ class NodeExtentAccessorT {
   const value_t* split_insert_replayable(
       StagedIterator& split_at,
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       position_t& insert_pos,
       match_stage_t& insert_stage,
       node_offset_t& insert_size) {

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 3267cda2bfec925806f2f14fd424fad12764d19c..319562d5d19a23152d84f923882e840e4e54ea2d 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_impl.h
@@ -112,12 +112,12 @@ class InternalNodeImpl : public NodeImpl {
   }
   #pragma GCC diagnostic ignored "-Woverloaded-virtual"
   virtual const laddr_packed_t* insert(
-      const key_view_t&, const laddr_packed_t&, search_position_t&, match_stage_t&, node_offset_t&) {
+      const key_view_t&, const laddr_t&, search_position_t&, match_stage_t&, node_offset_t&) {
     ceph_abort("impossible path");
   }
   #pragma GCC diagnostic ignored "-Woverloaded-virtual"
   virtual std::tuple<search_position_t, bool, const laddr_packed_t*> split_insert(
-      NodeExtentMutable&, NodeImpl&, const key_view_t&, const laddr_packed_t&,
+      NodeExtentMutable&, NodeImpl&, const key_view_t&, const laddr_t&,
       search_position_t&, match_stage_t&, node_offset_t&) {
     ceph_abort("impossible path");
   }

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 916d174243a8a712b00b5903b2610c77207465c3..cc5a83b6db047fa98837661643173bade03862e3 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
@@ -47,6 +47,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
   using marker_t = typename node_marker_type<NODE_TYPE>::type;
   using node_stage_t = typename extent_t::node_stage_t;
   using position_t = typename extent_t::position_t;
+  using value_input_t = typename extent_t::value_input_t;
   using value_t = typename extent_t::value_t;
   static constexpr auto FIELD_TYPE = extent_t::FIELD_TYPE;
   static constexpr auto KEY_TYPE = insert_key_type<NODE_TYPE>::type;
@@ -281,7 +282,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
   }
 
   const value_t* insert(
-      const full_key_t<KEY_TYPE>& key, const value_t& value,
+      const full_key_t<KEY_TYPE>& key, const value_input_t& value,
       search_position_t& insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
     logger().debug("OTree::Layout::Insert: begin at "
@@ -309,7 +310,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
 
   std::tuple<search_position_t, bool, const value_t*> split_insert(
       NodeExtentMutable& right_mut, NodeImpl& right_impl,
-      const full_key_t<KEY_TYPE>& key, const value_t& value,
+      const full_key_t<KEY_TYPE>& key, const value_input_t& value,
       search_position_t& _insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
     logger().info("OTree::Layout::Split: begin at "
@@ -536,17 +537,16 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       const key_view_t& key, const laddr_t& value,
       search_position_t& insert_pos) const override {
     if constexpr (NODE_TYPE == node_type_t::INTERNAL) {
-      auto packed_value = laddr_packed_t{value};
       auto& node_stage = extent.read();
       match_stage_t insert_stage;
       node_offset_t insert_size;
       if (unlikely(!node_stage.keys())) {
         assert(insert_pos.is_end());
         insert_stage = STAGE;
-        insert_size = STAGE_T::template insert_size<KeyT::VIEW>(key, packed_value);
+        insert_size = STAGE_T::template insert_size<KeyT::VIEW>(key, value);
       } else {
         std::tie(insert_stage, insert_size) = STAGE_T::evaluate_insert(
-            node_stage, key, packed_value, cast_down<STAGE>(insert_pos), false);
+            node_stage, key, value, cast_down<STAGE>(insert_pos), false);
       }
       return {insert_stage, insert_size};
     } else {

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 c1499d6093db0bb3d732a764714a4aecf68ea714..23497219a15430e5781e7124e7473bc931695818 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
@@ -23,6 +23,7 @@ struct NodeLayoutReplayableT {
   using node_stage_t = node_extent_t<FieldType, NODE_TYPE>;
   using position_t = typename STAGE_T::position_t;
   using StagedIterator = typename STAGE_T::StagedIterator;
+  using value_input_t = value_input_type_t<NODE_TYPE>;
   using value_t = value_type_t<NODE_TYPE>;
   static constexpr auto FIELD_TYPE = FieldType::FIELD_TYPE;
 
@@ -31,7 +32,7 @@ struct NodeLayoutReplayableT {
       NodeExtentMutable& mut,
       const node_stage_t& node_stage,
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       position_t& insert_pos,
       match_stage_t& insert_stage,
       node_offset_t& insert_size) {
@@ -54,7 +55,7 @@ struct NodeLayoutReplayableT {
       const node_stage_t& node_stage,
       StagedIterator& split_at,
       const full_key_t<KT>& key,
-      const value_t& value,
+      const value_input_t& value,
       position_t& insert_pos,
       match_stage_t& insert_stage,
       node_offset_t& insert_size) {

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h
index bb68eec8f19cfa7c1629180d19a450400cd831c4..c880b3c100e6147afe72ec2df04661925350b3fd 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/item_iterator_stage.h
@@ -35,6 +35,7 @@ class NodeExtentMutable;
  */
 template <node_type_t NODE_TYPE>
 class item_iterator_t {
+  using value_input_t = value_input_type_t<NODE_TYPE>;
   using value_t = value_type_t<NODE_TYPE>;
  public:
   item_iterator_t(const memory_range_t& range)
@@ -120,7 +121,7 @@ class item_iterator_t {
 
   template <KeyT KT>
   static node_offset_t estimate_insert(
-      const full_key_t<KT>& key, const value_t&) {
+      const full_key_t<KT>& key, const value_input_t&) {
     return ns_oid_view_t::estimate_size<KT>(key) + sizeof(node_offset_t);
   }
 

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc
index 4a59881857d62794cf6b714ec499594f3af21869..c39c640e949ea6e4effd8ad9d0bde2f713b44b72 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.cc
@@ -242,7 +242,7 @@ void APPEND_T::append(const node_extent_t& src, index_t from, index_t items) {
 template <typename FieldType, node_type_t NODE_TYPE>
 template <KeyT KT>
 void APPEND_T::append(
-    const full_key_t<KT>& key, const value_t& value, const value_t*& p_value) {
+    const full_key_t<KT>& key, const value_input_t& value, const value_t*& p_value) {
   if constexpr (FIELD_TYPE == field_type_t::N3) {
     ceph_abort("not implemented");
   } else {

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h
index cf0ca463cbf4b596ca892a047bfa4165d1619b3c..be98eb17ec490c5973e8aa5eed339050c81b8fc5 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage.h
@@ -25,6 +25,7 @@ class NodeExtentMutable;
 template <typename FieldType, node_type_t _NODE_TYPE>
 class node_extent_t {
  public:
+  using value_input_t = value_input_type_t<_NODE_TYPE>;
   using value_t = value_type_t<_NODE_TYPE>;
   using num_keys_t = typename FieldType::num_keys_t;
   static constexpr node_type_t NODE_TYPE = _NODE_TYPE;
@@ -137,7 +138,7 @@ class node_extent_t {
 
   template <KeyT KT>
   static node_offset_t estimate_insert(
-      const full_key_t<KT>& key, const value_t& value) {
+      const full_key_t<KT>& key, const value_input_t& value) {
     auto size = FieldType::estimate_insert_one();
     if constexpr (FIELD_TYPE == field_type_t::N2) {
       size += ns_oid_view_t::estimate_size<KT>(key);
@@ -151,7 +152,7 @@ class node_extent_t {
   template <KeyT KT>
   static const value_t* insert_at(
       NodeExtentMutable& mut, const node_extent_t&,
-      const full_key_t<KT>& key, const value_t& value,
+      const full_key_t<KT>& key, const value_input_t& value,
       index_t index, node_offset_t size, const char* p_left_bound) {
     if constexpr (FIELD_TYPE == field_type_t::N3) {
       ceph_abort("not implemented");
@@ -198,7 +199,7 @@ class node_extent_t<FieldType, NODE_TYPE>::Appender {
     p_append_right = p_start + FieldType::SIZE;
   }
   void append(const node_extent_t& src, index_t from, index_t items);
-  void append(const full_key_t<KT>&, const value_t&, const value_t*&);
+  void append(const full_key_t<KT>&, const value_input_t&, const value_t*&);
   char* wrap();
   std::tuple<NodeExtentMutable*, char*> open_nxt(const key_get_type&);
   std::tuple<NodeExtentMutable*, char*> open_nxt(const full_key_t<KT>&);

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 cac167a9820613b06fc22c0db0803ed2b11d1a76..794d654624291aad0276b5be0f51adcf513396a0 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
@@ -162,6 +162,7 @@ struct staged {
   using next_param_t = typename Params::next_param_t;
   using position_t = staged_position_t<Params::STAGE>;
   using result_t = staged_result_t<Params::NODE_TYPE, Params::STAGE>;
+  using value_input_t = value_input_type_t<Params::NODE_TYPE>;
   using value_t = value_type_t<Params::NODE_TYPE>;
   static constexpr auto CONTAINER_TYPE = container_t::CONTAINER_TYPE;
   static constexpr bool IS_BOTTOM = (Params::STAGE == STAGE_BOTTOM);
@@ -315,8 +316,11 @@ struct staged {
 
     template <KeyT KT, typename T = value_t>
     std::enable_if_t<IS_BOTTOM, const T*> insert(
-        NodeExtentMutable& mut, const full_key_t<KT>& key,
-        const value_t& value, node_offset_t insert_size, const char* p_left_bound) {
+        NodeExtentMutable& mut,
+        const full_key_t<KT>& key,
+        const value_input_t& value,
+        node_offset_t insert_size,
+        const char* p_left_bound) {
       return container_t::template insert_at<KT>(
           mut, container, key, value, _index, insert_size, p_left_bound);
     }
@@ -467,7 +471,7 @@ struct staged {
 
     template <KeyT KT>
     static node_offset_t estimate_insert(
-        const full_key_t<KT>& key, const value_t& value) {
+        const full_key_t<KT>& key, const value_input_t& value) {
       return container_t::template estimate_insert<KT>(key, value);
     }
 
@@ -783,7 +787,8 @@ struct staged {
     }
 
     template <KeyT KT>
-    static node_offset_t estimate_insert(const full_key_t<KT>& key, const value_t& value) {
+    static node_offset_t estimate_insert(const full_key_t<KT>& key,
+                                         const value_input_t& value) {
       return container_t::template estimate_insert<KT>(key, value);
     }
 
@@ -1044,7 +1049,8 @@ struct staged {
   }
 
   template <KeyT KT>
-  static node_offset_t insert_size(const full_key_t<KT>& key, const value_t& value) {
+  static node_offset_t insert_size(const full_key_t<KT>& key,
+                                   const value_input_t& value) {
     if constexpr (IS_BOTTOM) {
       return iterator_t::template estimate_insert<KT>(key, value);
     } else {
@@ -1055,8 +1061,9 @@ struct staged {
   }
 
   template <KeyT KT>
-  static node_offset_t insert_size_at(
-      match_stage_t stage, const full_key_t<KeyT::HOBJ>& key, const value_t& value) {
+  static node_offset_t insert_size_at(match_stage_t stage,
+                                      const full_key_t<KeyT::HOBJ>& key,
+                                      const value_input_t& value) {
     if (stage == STAGE) {
       return insert_size<KT>(key, value);
     } else {
@@ -1068,7 +1075,7 @@ struct staged {
   template <typename T = std::tuple<match_stage_t, node_offset_t>>
   static std::enable_if_t<NODE_TYPE == node_type_t::INTERNAL, T> evaluate_insert(
       const container_t& container, const full_key_t<KeyT::VIEW>& key,
-      const value_t& value, position_t& position, bool evaluate_last) {
+      const value_input_t& value, position_t& position, bool evaluate_last) {
     auto iter = iterator_t(container);
     auto& index = position.index;
     if (evaluate_last || index == INDEX_END) {
@@ -1212,7 +1219,7 @@ struct staged {
   template <KeyT KT>
   static const value_t* insert_new(
       NodeExtentMutable& mut, const memory_range_t& range,
-      const full_key_t<KT>& key, const value_t& value) {
+      const full_key_t<KT>& key, const value_input_t& value) {
     char* p_insert = const_cast<char*>(range.p_end);
     const value_t* p_value = nullptr;
     StagedAppender<KT> appender;
@@ -1226,7 +1233,7 @@ struct staged {
   template <KeyT KT, bool SPLIT>
   static const value_t* proceed_insert_recursively(
       NodeExtentMutable& mut, const container_t& container,
-      const full_key_t<KT>& key, const value_t& value,
+      const full_key_t<KT>& key, const value_input_t& value,
       position_t& position, match_stage_t& stage,
       node_offset_t& _insert_size, const char* p_left_bound) {
     // proceed insert from right to left
@@ -1295,7 +1302,7 @@ struct staged {
   template <KeyT KT, bool SPLIT>
   static const value_t* proceed_insert(
       NodeExtentMutable& mut, const container_t& container,
-      const full_key_t<KT>& key, const value_t& value,
+      const full_key_t<KT>& key, const value_input_t& value,
       position_t& position, match_stage_t& stage, node_offset_t& _insert_size) {
     auto p_left_bound = container.p_left_bound();
     if (unlikely(!container.keys())) {
@@ -1796,7 +1803,7 @@ struct staged {
    *       -> std::tuple<NodeExtentMutable&, char*>
    *   wrap_nxt(char* p_append)
    * ELSE
-   *   append(const full_key_t& key, const value_t& value)
+   *   append(const full_key_t& key, const value_input_t& value)
    */
   template <KeyT KT>
   struct _BaseWithNxtAppender {
@@ -1839,7 +1846,7 @@ struct staged {
       }
     }
     void append(const full_key_t<KT>& key,
-                const value_t& value, const value_t*& p_value) {
+                const value_input_t& value, const value_t*& p_value) {
       assert(!require_wrap_nxt);
       if constexpr (!IS_BOTTOM) {
         auto& nxt = open_nxt(key);
@@ -1989,7 +1996,7 @@ struct staged {
 
   template <KeyT KT>
   static bool append_insert(
-      const full_key_t<KT>& key, const value_t& value,
+      const full_key_t<KT>& key, const value_input_t& value,
       StagedIterator& src_iter, StagedAppender<KT>& appender,
       bool is_front_insert, match_stage_t& stage, const value_t*& p_value) {
     assert(src_iter.valid());

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h
index a9d5cef3b4a9581fbfb8322f2c9cb0c31033650e..02fe11ab97f9cc0fa223c523eeb52bbef43da376 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/stage_types.h
@@ -356,6 +356,13 @@ struct memory_range_t {
 
 enum class ContainerType { ITERATIVE, INDEXABLE };
 
+// the input type to construct the value during insert.
+template <node_type_t> struct value_input_type;
+template<> struct value_input_type<node_type_t::INTERNAL> { using type = laddr_t; };
+template<> struct value_input_type<node_type_t::LEAF> { using type = onode_t; };
+template <node_type_t NODE_TYPE>
+using value_input_type_t = typename value_input_type<NODE_TYPE>::type;
+
 template <node_type_t> struct value_type;
 template<> struct value_type<node_type_t::INTERNAL> { using type = laddr_packed_t; };
 template<> struct value_type<node_type_t::LEAF> { using type = onode_t; };

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc
index aaca6c3c622cab8a0f6d6a48ce40164ee04079bd..10f157809625614e397d83920c0e189172a37b73 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.cc
@@ -10,7 +10,7 @@ namespace crimson::os::seastore::onode {
 template <KeyT KT>
 const laddr_packed_t* internal_sub_items_t::insert_at(
     NodeExtentMutable& mut, const internal_sub_items_t& sub_items,
-    const full_key_t<KT>& key, const laddr_packed_t& value,
+    const full_key_t<KT>& key, const laddr_t& value,
     index_t index, node_offset_t size, const char* p_left_bound) {
   assert(index <= sub_items.keys());
   assert(size == estimate_insert<KT>(key, value));
@@ -20,14 +20,15 @@ const laddr_packed_t* internal_sub_items_t::insert_at(
   mut.shift_absolute(p_shift_start, p_shift_end - p_shift_start, -(int)size);
 
   auto p_insert = const_cast<char*>(p_shift_end) - size;
-  auto item = internal_sub_item_t{snap_gen_t::from_key<KT>(key), value};
+  auto item = internal_sub_item_t{
+    snap_gen_t::from_key<KT>(key), laddr_packed_t{value}};
   mut.copy_in_absolute(p_insert, item);
   return &reinterpret_cast<internal_sub_item_t*>(p_insert)->value;
 }
 #define IA_TEMPLATE(KT)                                                     \
   template const laddr_packed_t* internal_sub_items_t::insert_at<KT>(       \
     NodeExtentMutable&, const internal_sub_items_t&, const full_key_t<KT>&, \
-    const laddr_packed_t&, index_t, node_offset_t, const char*)
+    const laddr_t&, index_t, node_offset_t, const char*)
 IA_TEMPLATE(KeyT::VIEW);
 IA_TEMPLATE(KeyT::HOBJ);
 
@@ -57,10 +58,11 @@ void internal_sub_items_t::Appender<KT>::append(
 
 template <KeyT KT>
 void internal_sub_items_t::Appender<KT>::append(
-    const full_key_t<KT>& key, const laddr_packed_t& value,
+    const full_key_t<KT>& key, const laddr_t& value,
     const laddr_packed_t*& p_value) {
   p_append -= sizeof(internal_sub_item_t);
-  auto item = internal_sub_item_t{snap_gen_t::from_key<KT>(key), value};
+  auto item = internal_sub_item_t{
+    snap_gen_t::from_key<KT>(key), laddr_packed_t{value}};
   p_mut->copy_in_absolute(p_append, item);
   p_value = &reinterpret_cast<internal_sub_item_t*>(p_append)->value;
 }

diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h
index 8ef5f747263b04a6589a9248b929ac62776f5634..e19664427edd76167e69e4c81d6a45c2b0c439cc 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/stages/sub_items_stage.h
@@ -98,14 +98,14 @@ class internal_sub_items_t {
 
   template <KeyT KT>
   static node_offset_t estimate_insert(
-      const full_key_t<KT>&, const laddr_packed_t&) {
+      const full_key_t<KT>&, const laddr_t&) {
     return sizeof(internal_sub_item_t);
   }
 
   template <KeyT KT>
   static const laddr_packed_t* insert_at(
       NodeExtentMutable&, const internal_sub_items_t&,
-      const full_key_t<KT>&, const laddr_packed_t&,
+      const full_key_t<KT>&, const laddr_t&,
       index_t index, node_offset_t size, const char* p_left_bound);
 
   static node_offset_t trim_until(NodeExtentMutable&, internal_sub_items_t&, index_t);
@@ -124,7 +124,7 @@ class internal_sub_items_t::Appender {
   Appender(NodeExtentMutable* p_mut, char* p_append)
     : p_mut{p_mut}, p_append{p_append} {}
   void append(const internal_sub_items_t& src, index_t from, index_t items);
-  void append(const full_key_t<KT>&, const laddr_packed_t&, const laddr_packed_t*&);
+  void append(const full_key_t<KT>&, const laddr_t&, const laddr_packed_t*&);
   char* wrap() { return p_append; }
  private:
   NodeExtentMutable* p_mut;

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 da7422bcb02f77614a79f9344a89e424b52a9b7f..ad14c34502dc90e09eaff74217cac2e87d4d306b 100644 (file)
--- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
+++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
@@ -97,7 +97,7 @@ TEST_F(a_basic_test_t, 1_basic_sizes)
   onode_t value = {2};
 #define _STAGE_T(NodeType) node_to_stage_t<typename NodeType::node_stage_t>
 #define NXT_T(StageType)  staged<typename StageType::next_param_t>
-  laddr_packed_t i_value{0};
+  laddr_t i_value{0};
   logger().info("\n"
     "Bytes of a key-value insertion (full-string):\n"
     "  s-p-c, 'n'-'o', s-g => onode_t(2): typically internal 41B, leaf 35B\n"