crimson/seastore: improve metrics about onode and lba trees

Absolute value:
* tree_depth
By transaction source:
* 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 d30a73a1503ec0b9da539f04d50721453c8bcaa8..2a3e91cf6d68624c341f5fe5c185514d937dcbb4 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -435,82 +435,78 @@ void Cache::register_metrics()
    */
   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}
-      ),
+  auto register_tree_metrics = [&labels_by_src, &onode_label, this](
+      const sm::label_instance& tree_label,
+      uint64_t& tree_depth,
+      counter_by_src_t<tree_efforts_t>& committed_tree_efforts,
+      counter_by_src_t<tree_efforts_t>& invalidated_tree_efforts) {
+    tree_depth = 0;
+    metrics.add_group(
+      "cache",
+      {
+        sm::make_counter(
+          "tree_depth",
+          tree_depth,
+          sm::description("the depth of tree"),
+          {tree_label}
+        ),
+      }
+    );
+    committed_tree_efforts.fill({});
+    invalidated_tree_efforts.fill({});
+    for (auto& [src, src_label] : labels_by_src) {
+      if (src == src_t::READ) {
+        // READ transaction won't contain any tree inserts and erases
+        continue;
+      }
+      if (src == src_t::CLEANER && tree_label == onode_label) {
+        // CLEANER transaction won't contain any onode tree operations
+        continue;
+      }
+      auto& committed_efforts = get_by_src(committed_tree_efforts, src);
+      auto& invalidated_efforts = get_by_src(invalidated_tree_efforts, src);
+      metrics.add_group(
+        "cache",
+        {
+          sm::make_counter(
+            "tree_inserts_committed",
+            committed_efforts.num_inserts,
+            sm::description("total number of committed insert operations"),
+            {tree_label, src_label}
+          ),
+          sm::make_counter(
+            "tree_erases_committed",
+            committed_efforts.num_erases,
+            sm::description("total number of committed erase operations"),
+            {tree_label, src_label}
+          ),
+          sm::make_counter(
+            "tree_inserts_invalidated",
+            invalidated_efforts.num_inserts,
+            sm::description("total number of invalidated insert operations"),
+            {tree_label, src_label}
+          ),
+          sm::make_counter(
+            "tree_erases_invalidated",
+            invalidated_efforts.num_erases,
+            sm::description("total number of invalidated erase operations"),
+            {tree_label, src_label}
+          ),
+        }
+      );
     }
-  );
+  };
+  register_tree_metrics(
+      onode_label,
+      stats.onode_tree_depth,
+      stats.committed_onode_tree_efforts,
+      stats.invalidated_onode_tree_efforts);
+  register_tree_metrics(
+      lba_label,
+      stats.lba_tree_depth,
+      stats.committed_lba_tree_efforts,
+      stats.invalidated_lba_tree_efforts);
 }
 
 void Cache::add_extent(CachedExtentRef ref)
@@ -664,8 +660,16 @@ void Cache::invalidate(Transaction& t, CachedExtent& conflicting_extent)
       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);
+    if (t.get_src() == Transaction::src_t::CLEANER) {
+      // CLEANER transaction won't contain any onode tree operations
+      assert(t.onode_tree_stats.is_clear());
+    } else {
+      get_by_src(stats.invalidated_onode_tree_efforts, t.get_src()
+          ).increment(t.onode_tree_stats);
+    }
+
+    get_by_src(stats.invalidated_lba_tree_efforts, t.get_src()
+        ).increment(t.lba_tree_stats);
   } else {
     // read transaction won't have non-read efforts
     assert(t.retired_set.empty());
@@ -769,8 +773,24 @@ 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);
+
+  if (t.get_src() == Transaction::src_t::CLEANER) {
+    // CLEANER transaction won't contain any onode tree operations
+    assert(t.onode_tree_stats.is_clear());
+  } else {
+    if (t.onode_tree_stats.depth) {
+      stats.onode_tree_depth = t.onode_tree_stats.depth;
+    }
+    get_by_src(stats.committed_onode_tree_efforts, t.get_src()
+        ).increment(t.onode_tree_stats);
+  }
+
+  if (t.lba_tree_stats.depth) {
+    stats.lba_tree_depth = t.lba_tree_stats.depth;
+  }
+  get_by_src(stats.committed_lba_tree_efforts, t.get_src()
+      ).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 0417dbff9f448ffd633b67b1962648048c5ce4d8..d111ab6251489d16f38c086d0004f58f8172a685 100644 (file)
--- a/src/crimson/os/seastore/cache.h
+++ b/src/crimson/os/seastore/cache.h
@@ -628,6 +628,16 @@ private:
     counter_by_extent_t<effort_t> fresh_by_ext;
   };
 
+  struct tree_efforts_t {
+    uint64_t num_inserts = 0;
+    uint64_t num_erases = 0;
+
+    void increment(const Transaction::tree_stats_t& incremental) {
+      num_inserts += incremental.num_inserts;
+      num_erases += incremental.num_erases;
+    }
+  };
+
   template <typename CounterT>
   using counter_by_src_t = std::array<CounterT, Transaction::SRC_MAX>;
 
@@ -641,10 +651,14 @@ 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;
+
+    uint64_t onode_tree_depth;
+    counter_by_src_t<tree_efforts_t> committed_onode_tree_efforts;
+    counter_by_src_t<tree_efforts_t> invalidated_onode_tree_efforts;
+
+    uint64_t lba_tree_depth;
+    counter_by_src_t<tree_efforts_t> committed_lba_tree_efforts;
+    counter_by_src_t<tree_efforts_t> invalidated_lba_tree_efforts;
   } stats;
 
   template <typename CounterT>

diff --git a/src/crimson/os/seastore/transaction.h b/src/crimson/os/seastore/transaction.h
index 2041d8cff015c5eb5002d82838fe6a66f92a2a1e..31197982756da32fe015374da2e3173d48b30687 100644 (file)
--- a/src/crimson/os/seastore/transaction.h
+++ b/src/crimson/os/seastore/transaction.h
@@ -227,14 +227,6 @@ public:
               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;