crimson/os/seastore/cache: report rewrite stats

Signed-off-by: Yingxin Cheng <[email protected]>

Author: cyx1231st

src/crimson/os/seastore/cache.cc

@@ -148,6 +148,8 @@ void Cache::register_metrics()
   stats = {};
   last_dirty_io = {};
   last_dirty_io_by_src_ext = {};
+  last_trim_rewrites = {};
+  last_reclaim_rewrites = {};
 
   namespace sm = seastar::metrics;
   using src_t = Transaction::src_t;
@@ -705,22 +707,26 @@ void Cache::register_metrics()
     {
       sm::make_counter(
         "version_count_dirty",
-        stats.trim_rewrites.num,
+        [this] {
+          return stats.trim_rewrites.get_num_rewrites();
+        },
         sm::description("total number of rewrite-dirty extents")
       ),
       sm::make_counter(
         "version_sum_dirty",
-        stats.trim_rewrites.version,
+        stats.trim_rewrites.dirty_version,
         sm::description("sum of the version from rewrite-dirty extents")
       ),
       sm::make_counter(
         "version_count_reclaim",
-        stats.reclaim_rewrites.num,
+        [this] {
+          return stats.reclaim_rewrites.get_num_rewrites();
+        },
         sm::description("total number of rewrite-reclaim extents")
       ),
       sm::make_counter(
         "version_sum_reclaim",
-        stats.reclaim_rewrites.version,
+        stats.reclaim_rewrites.dirty_version,
         sm::description("sum of the version from rewrite-reclaim extents")
       ),
     }
@@ -2333,9 +2339,29 @@ cache_stats_t Cache::get_stats(
           << dirty_io_stats_printer_t{seconds, phys_io};
     }
 
+    constexpr const char* dfmt = "{:.2f}";
+    rewrite_stats_t _trim_rewrites = stats.trim_rewrites;
+    _trim_rewrites.minus(last_trim_rewrites);
+    rewrite_stats_t _reclaim_rewrites = stats.reclaim_rewrites;
+    _reclaim_rewrites.minus(last_reclaim_rewrites);
+    oss << "\nrewrite trim ndirty="
+        << fmt::format(dfmt, _trim_rewrites.num_n_dirty/seconds)
+        << "ps, dirty="
+        << fmt::format(dfmt, _trim_rewrites.num_dirty/seconds)
+        << "ps, dversion="
+        << fmt::format(dfmt, _trim_rewrites.get_avg_version())
+        << "; reclaim ndirty="
+        << fmt::format(dfmt, _reclaim_rewrites.num_n_dirty/seconds)
+        << "ps, dirty="
+        << fmt::format(dfmt, _reclaim_rewrites.num_dirty/seconds)
+        << "ps, dversion="
+        << fmt::format(dfmt, _reclaim_rewrites.get_avg_version());
+
     INFO("{}", oss.str());
 
     last_dirty_io_by_src_ext = stats.dirty_io_by_src_ext;
+    last_trim_rewrites = stats.trim_rewrites;
+    last_reclaim_rewrites = stats.reclaim_rewrites;
   }
 
   last_dirty_io = stats.dirty_io;

src/crimson/os/seastore/cache.h

@@ -1638,6 +1638,8 @@ class Cache {
   mutable dirty_io_stats_t last_dirty_io;
   mutable counter_by_src_t<counter_by_extent_t<dirty_io_stats_t> >
     last_dirty_io_by_src_ext;
+  mutable rewrite_stats_t last_trim_rewrites;
+  mutable rewrite_stats_t last_reclaim_rewrites;
 
   void account_conflict(Transaction::src_t src1, Transaction::src_t src2) {
     assert(src1 < Transaction::src_t::MAX);

src/crimson/os/seastore/transaction.h

@@ -42,21 +42,41 @@ inline std::ostream& operator<<(std::ostream& out, const io_stat_t& stat) {
 }
 
 struct rewrite_stats_t {
-  uint64_t num = 0;
-  uint64_t version = 0;
+  uint64_t num_n_dirty = 0;
+  uint64_t num_dirty = 0;
+  uint64_t dirty_version = 0;
 
   bool is_clear() const {
-    return num == 0;
+    return (num_n_dirty == 0 && num_dirty == 0);
   }
 
-  void account(extent_version_t v) {
-    ++num;
-    version += v;
+  uint64_t get_num_rewrites() const {
+    return num_n_dirty + num_dirty;
+  }
+
+  double get_avg_version() const {
+    return static_cast<double>(dirty_version)/num_dirty;
+  }
+
+  void account_n_dirty() {
+    ++num_n_dirty;
+  }
+
+  void account_dirty(extent_version_t v) {
+    ++num_dirty;
+    dirty_version += v;
   }
 
   void add(const rewrite_stats_t& o) {
-    num += o.num;
-    version += o.version;
+    num_n_dirty += o.num_n_dirty;
+    num_dirty += o.num_dirty;
+    dirty_version += o.dirty_version;
+  }
+
+  void minus(const rewrite_stats_t& o) {
+    num_n_dirty -= o.num_n_dirty;
+    num_dirty -= o.num_dirty;
+    dirty_version -= o.dirty_version;
   }
 };
 

src/crimson/os/seastore/transaction_manager.cc

@@ -639,6 +639,13 @@ TransactionManager::rewrite_extent_ret TransactionManager::rewrite_extent(
   assert(extent->is_valid() && !extent->is_initial_pending());
   if (extent->is_dirty()) {
     assert(extent->get_version() > 0);
+    if (is_root_type(extent->get_type())) {
+      // pass
+    } else if (extent->get_version() == 1 && extent->is_mutation_pending()) {
+      t.get_rewrite_stats().account_n_dirty();
+    } else {
+      t.get_rewrite_stats().account_dirty(extent->get_version());
+    }
     if (epm->can_inplace_rewrite(t, extent)) {
       DEBUGT("delta overwriting extent -- {}", t, *extent);
       t.add_inplace_rewrite_extent(extent);
@@ -647,14 +654,14 @@ TransactionManager::rewrite_extent_ret TransactionManager::rewrite_extent(
     }
     extent->set_target_rewrite_generation(INIT_GENERATION);
   } else {
+    assert(!is_root_type(extent->get_type()));
     extent->set_target_rewrite_generation(target_generation);
     ceph_assert(modify_time != NULL_TIME);
     extent->set_modify_time(modify_time);
     assert(extent->get_version() == 0);
+    t.get_rewrite_stats().account_n_dirty();
   }
 
-  t.get_rewrite_stats().account(extent->get_version());
-
   if (is_backref_node(extent->get_type())) {
     DEBUGT("rewriting backref extent -- {}", t, *extent);
     return backref_manager->rewrite_extent(t, extent);