crimson/seastore: add metrics about onode and lba trees

* tree_depth
* tree_inserts_committed
* tree_inserts_invalidated
* tree_erases_committed
* tree_erase_invalidated

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

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index c96d535b18221cba5128b51b5233777ff6aa0843..d30a73a1503ec0b9da539f04d50721453c8bcaa8 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -429,6 +429,88 @@ void Cache::register_metrics()
       ),
     }
   );
+
+  /**
+   * tree stats
+   */
+  auto tree_label = sm::label("tree");
+  auto onode_label = tree_label("ONODE");
+  stats.committed_onode_tree_stats = {};
+  stats.invalidated_onode_tree_stats = {};
+  metrics.add_group(
+    "cache",
+    {
+      sm::make_counter(
+        "tree_depth",
+        stats.committed_onode_tree_stats.depth,
+        sm::description("the depth of tree"),
+        {onode_label}
+      ),
+      sm::make_counter(
+        "tree_inserts_committed",
+        stats.committed_onode_tree_stats.num_inserts,
+        sm::description("total number of committed insert operations"),
+        {onode_label}
+      ),
+      sm::make_counter(
+        "tree_erases_committed",
+        stats.committed_onode_tree_stats.num_erases,
+        sm::description("total number of committed erase operations"),
+        {onode_label}
+      ),
+      sm::make_counter(
+        "tree_inserts_invalidated",
+        stats.invalidated_onode_tree_stats.num_inserts,
+        sm::description("total number of invalidated insert operations"),
+        {onode_label}
+      ),
+      sm::make_counter(
+        "tree_erases_invalidated",
+        stats.invalidated_onode_tree_stats.num_erases,
+        sm::description("total number of invalidated erase operations"),
+        {onode_label}
+      ),
+    }
+  );
+
+  auto lba_label = tree_label("LBA");
+  stats.committed_lba_tree_stats = {};
+  stats.invalidated_lba_tree_stats = {};
+  metrics.add_group(
+    "cache",
+    {
+      sm::make_counter(
+        "tree_depth",
+        stats.committed_lba_tree_stats.depth,
+        sm::description("the depth of tree"),
+        {lba_label}
+      ),
+      sm::make_counter(
+        "tree_inserts_committed",
+        stats.committed_lba_tree_stats.num_inserts,
+        sm::description("total number of committed insert operations"),
+        {lba_label}
+      ),
+      sm::make_counter(
+        "tree_erases_committed",
+        stats.committed_lba_tree_stats.num_erases,
+        sm::description("total number of committed erase operations"),
+        {lba_label}
+      ),
+      sm::make_counter(
+        "tree_inserts_invalidated",
+        stats.invalidated_lba_tree_stats.num_inserts,
+        sm::description("total number of invalidated insert operations"),
+        {lba_label}
+      ),
+      sm::make_counter(
+        "tree_erases_invalidated",
+        stats.invalidated_lba_tree_stats.num_erases,
+        sm::description("total number of invalidated erase operations"),
+        {lba_label}
+      ),
+    }
+  );
 }
 
 void Cache::add_extent(CachedExtentRef ref)
@@ -581,11 +663,16 @@ void Cache::invalidate(Transaction& t, CachedExtent& conflicting_extent)
       efforts.mutate.increment(i->get_length());
       efforts.mutate_delta_bytes += i->get_delta().length();
     }
+
+    stats.invalidated_onode_tree_stats.increment(t.onode_tree_stats);
+    stats.invalidated_lba_tree_stats.increment(t.lba_tree_stats);
   } else {
     // read transaction won't have non-read efforts
     assert(t.retired_set.empty());
     assert(t.fresh_block_list.empty());
     assert(t.mutated_block_list.empty());
+    assert(t.onode_tree_stats.is_clear());
+    assert(t.lba_tree_stats.is_clear());
   }
 }
 
@@ -607,6 +694,8 @@ void Cache::on_transaction_destruct(Transaction& t)
     assert(t.retired_set.empty());
     assert(t.fresh_block_list.empty());
     assert(t.mutated_block_list.empty());
+    assert(t.onode_tree_stats.is_clear());
+    assert(t.lba_tree_stats.is_clear());
   }
 }
 
@@ -680,6 +769,8 @@ record_t Cache::prepare_record(Transaction &t)
 
   assert(!t.is_weak());
   assert(t.get_src() != Transaction::src_t::READ);
+  stats.committed_onode_tree_stats.increment(t.onode_tree_stats);
+  stats.committed_lba_tree_stats.increment(t.lba_tree_stats);
   ++(get_by_src(stats.trans_committed_by_src, t.get_src()));
   auto& efforts = get_by_src(stats.committed_efforts_by_src,
                              t.get_src());

diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h
index a6212ff6d0330f2650a612a0027e44cf472622b6..0417dbff9f448ffd633b67b1962648048c5ce4d8 100644 (file)
--- a/src/crimson/os/seastore/cache.h
+++ b/src/crimson/os/seastore/cache.h
@@ -641,6 +641,10 @@ private:
     uint64_t read_transactions_successful;
     effort_t read_effort_successful;
     uint64_t dirty_bytes;
+    Transaction::tree_stats_t committed_onode_tree_stats;
+    Transaction::tree_stats_t committed_lba_tree_stats;
+    Transaction::tree_stats_t invalidated_onode_tree_stats;
+    Transaction::tree_stats_t invalidated_lba_tree_stats;
   } stats;
 
   template <typename CounterT>

diff --git a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
index b98181ede772a015081710b2f6371b5c0b243018..0202423c014d90dc53cf0de06fdb60d4d4c3f481 100644 (file)
--- a/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
+++ b/src/crimson/os/seastore/lba_manager/btree/btree_lba_manager.cc
@@ -33,6 +33,7 @@ BtreeLBAManager::mkfs_ret BtreeLBAManager::mkfs(
     root_leaf->pin.set_range(meta);
     croot->get_root().lba_root =
       lba_root_t{root_leaf->get_paddr(), 1u};
+    t.get_lba_tree_stats().depth = 1u;
     return mkfs_iertr::now();
   }).handle_error_interruptible(
     mkfs_iertr::pass_further{},
@@ -512,6 +513,7 @@ BtreeLBAManager::insert_mapping_ret BtreeLBAManager::insert_mapping(
   laddr_t laddr,
   lba_map_val_t val)
 {
+  ++(t.get_lba_tree_stats().num_inserts);
   auto split = insert_mapping_iertr::future<LBANodeRef>(
     interruptible::ready_future_marker{},
     root);
@@ -534,10 +536,12 @@ BtreeLBAManager::insert_mapping_ret BtreeLBAManager::insert_mapping(
          L_ADDR_MIN,
          root->get_paddr(),
          nullptr);
+       auto new_depth = root->get_node_meta().depth + 1;
        croot->get_root().lba_root = lba_root_t{
          nroot->get_paddr(),
-         root->get_node_meta().depth + 1
+         new_depth
        };
+       t.get_lba_tree_stats().depth = new_depth;
        return nroot->split_entry(
          get_context(t),
          laddr, nroot->begin(), root);

diff --git a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
index 41bab2893cc617184a5264f667b9725b4581cae6..d11f27a57ad467795680b541cbac44776eb83e22 100644 (file)
--- a/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
+++ b/src/crimson/os/seastore/lba_manager/btree/lba_btree_node_impl.cc
@@ -420,9 +420,11 @@ LBAInternalNode::merge_entry(
            croot = mut_croot->cast<RootBlock>();
          }
          auto new_root_addr = begin()->get_val().maybe_relative_to(get_paddr());
+         auto new_depth = get_meta().depth - 1;
          croot->get_root().lba_root = lba_root_t{
            new_root_addr,
-           get_meta().depth - 1};
+           new_depth};
+         c.trans.get_lba_tree_stats().depth = new_depth;
          logger().debug(
            "LBAInternalNode::merge_entry: collapsing root {} to addr {}",
            *this,
@@ -607,6 +609,7 @@ LBALeafNode::mutate_mapping_ret LBALeafNode::mutate_mapping_internal(
       interruptible::ready_future_marker{},
       mutated);
   } else {
+    ++(c.trans.get_lba_tree_stats().num_erases);
     journal_remove(mutation_pt, maybe_get_delta_buffer());
     return mutate_mapping_ret(
       interruptible::ready_future_marker{},

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 da324075b172fb455c0d82cee16aad44d3478a42..4171490e639313eccf5c7dae200dc56ecc8d26ba 100644 (file)
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
@@ -439,6 +439,7 @@ void Node::make_root(context_t c, Super::URef&& _super)
 {
   _super->write_root_laddr(c, impl->laddr());
   as_root(std::move(_super));
+  c.t.get_onode_tree_stats().depth = static_cast<uint64_t>(level()) + 1;
 }
 
 void Node::as_root(Super::URef&& _super)
@@ -1813,6 +1814,7 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
   Ref<Node> this_ref = this;
   DEBUGT("erase {}'s pos({}), get_next={} ...",
          c.t, get_name(), pos, get_next);
+  ++(c.t.get_onode_tree_stats().num_erases);
 
   // get the next cursor
   return eagain_iertr::now().si_then([c, &pos, get_next, this] {
@@ -2043,6 +2045,7 @@ eagain_ifuture<Ref<tree_cursor_t>> LeafNode::insert_value(
   DEBUGT("insert {} with insert_key={}, insert_value={}, insert_pos({}), "
          "history={}, mstat({}) ...",
          c.t, get_name(), key, vconf, pos, history, mstat);
+  ++(c.t.get_onode_tree_stats().num_inserts);
   search_position_t insert_pos = pos;
   auto [insert_stage, insert_size] = impl->evaluate_insert(
       key, vconf, history, mstat, insert_pos);

diff --git a/src/crimson/os/seastore/transaction.h b/src/crimson/os/seastore/transaction.h
index 11be54a37a388e6ba142bfb7d64fd2dd6456815e..2041d8cff015c5eb5002d82838fe6a66f92a2a1e 100644 (file)
--- a/src/crimson/os/seastore/transaction.h
+++ b/src/crimson/os/seastore/transaction.h
@@ -204,6 +204,8 @@ public:
     fresh_block_list.clear();
     mutated_block_list.clear();
     retired_set.clear();
+    onode_tree_stats = {};
+    lba_tree_stats = {};
     to_release = NULL_SEG_ID;
     conflicted = false;
     if (!has_reset) {
@@ -215,6 +217,32 @@ public:
     return has_reset;
   }
 
+  struct tree_stats_t {
+    uint64_t depth = 0;
+    uint64_t num_inserts = 0;
+    uint64_t num_erases = 0;
+
+    bool is_clear() const {
+      return (depth == 0 &&
+              num_inserts == 0 &&
+              num_erases == 0);
+    }
+    void increment(const tree_stats_t& incremental) {
+      if (incremental.depth != 0) {
+        // depth is an absolute value
+        depth = incremental.depth;
+      }
+      num_inserts += incremental.num_inserts;
+      num_erases += incremental.num_erases;
+    }
+  };
+  tree_stats_t& get_onode_tree_stats() {
+    return onode_tree_stats;
+  }
+  tree_stats_t& get_lba_tree_stats() {
+    return lba_tree_stats;
+  }
+
 private:
   friend class Cache;
   friend Ref make_test_transaction();
@@ -237,6 +265,9 @@ private:
 
   pextent_set_t retired_set; ///< list of extents mutated by this transaction
 
+  tree_stats_t onode_tree_stats;
+  tree_stats_t lba_tree_stats;
+
   ///< if != NULL_SEG_ID, release this segment after completion
   segment_id_t to_release = NULL_SEG_ID;