crimson/os/seastore: cleanup, consolidate alloc_tail/dirty_tail naming

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

diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc
index c64adcd88c376b2b21bb4d156333a03c2becb34e..776e32b394ed8866c25b479a926def6630b82135 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -688,7 +688,7 @@ void AsyncCleaner::close_segment(segment_id_t segment)
        seg_info);
 }
 
-AsyncCleaner::trim_backrefs_ret AsyncCleaner::trim_backrefs(
+AsyncCleaner::trim_alloc_ret AsyncCleaner::trim_alloc(
   Transaction &t,
   journal_seq_t limit)
 {
@@ -785,20 +785,20 @@ AsyncCleaner::gc_cycle_ret AsyncCleaner::GCProcess::run()
 
 AsyncCleaner::gc_cycle_ret AsyncCleaner::do_gc_cycle()
 {
-  if (gc_should_trim_backref()) {
-    return gc_trim_backref(get_alloc_tail_target()
+  if (gc_should_trim_alloc()) {
+    return gc_trim_alloc(get_alloc_tail_target()
     ).safe_then([](auto) {
       return seastar::now();
     }).handle_error(
       crimson::ct_error::assert_all{
-       "GCProcess::run encountered invalid error in gc_trim_backref"
+       "GCProcess::run encountered invalid error in gc_trim_alloc"
       }
     );
-  } else if (gc_should_trim_journal()) {
-    return gc_trim_journal(
+  } else if (gc_should_trim_dirty()) {
+    return gc_trim_dirty(
     ).handle_error(
       crimson::ct_error::assert_all{
-       "GCProcess::run encountered invalid error in gc_trim_journal"
+       "GCProcess::run encountered invalid error in gc_trim_dirty"
       }
     );
   } else if (gc_should_reclaim_space()) {
@@ -813,50 +813,50 @@ AsyncCleaner::gc_cycle_ret AsyncCleaner::do_gc_cycle()
   }
 }
 
-AsyncCleaner::gc_trim_backref_ret
-AsyncCleaner::gc_trim_backref(journal_seq_t limit) {
+AsyncCleaner::gc_trim_alloc_ret
+AsyncCleaner::gc_trim_alloc(journal_seq_t limit) {
   return seastar::do_with(
     journal_seq_t(),
     [this, limit=std::move(limit)](auto &seq) mutable {
     return repeat_eagain([this, limit=std::move(limit), &seq] {
       return ecb->with_transaction_intr(
-       Transaction::src_t::TRIM_BACKREF,
-       "trim_backref",
+       Transaction::src_t::CLEANER_TRIM_ALLOC,
+       "trim_alloc",
        [this, limit](auto &t) {
-       return trim_backrefs(
+       return trim_alloc(
          t,
          limit
-       ).si_then([this, &t, limit](auto trim_backrefs_to)
+       ).si_then([this, &t, limit](auto trim_alloc_to)
          -> ExtentCallbackInterface::submit_transaction_direct_iertr::future<
            journal_seq_t> {
-         if (trim_backrefs_to != JOURNAL_SEQ_NULL) {
+         if (trim_alloc_to != JOURNAL_SEQ_NULL) {
            return ecb->submit_transaction_direct(
-             t, std::make_optional<journal_seq_t>(trim_backrefs_to)
-           ).si_then([trim_backrefs_to=std::move(trim_backrefs_to)]() mutable {
+             t, std::make_optional<journal_seq_t>(trim_alloc_to)
+           ).si_then([trim_alloc_to=std::move(trim_alloc_to)]() mutable {
              return seastar::make_ready_future<
-               journal_seq_t>(std::move(trim_backrefs_to));
+               journal_seq_t>(std::move(trim_alloc_to));
            });
          }
          return seastar::make_ready_future<journal_seq_t>(std::move(limit));
        });
-      }).safe_then([&seq](auto trim_backrefs_to) {
-       seq = std::move(trim_backrefs_to);
+      }).safe_then([&seq](auto trim_alloc_to) {
+       seq = std::move(trim_alloc_to);
       });
     }).safe_then([&seq] {
-      return gc_trim_backref_ertr::make_ready_future<
+      return gc_trim_alloc_ertr::make_ready_future<
        journal_seq_t>(std::move(seq));
     });
   });
 }
 
-AsyncCleaner::gc_trim_journal_ret AsyncCleaner::gc_trim_journal()
+AsyncCleaner::gc_trim_dirty_ret AsyncCleaner::gc_trim_dirty()
 {
-  return gc_trim_backref(get_dirty_tail_target()
+  return gc_trim_alloc(get_dirty_tail_target()
   ).safe_then([this](auto seq) {
     return repeat_eagain([this, seq=std::move(seq)]() mutable {
       return ecb->with_transaction_intr(
-       Transaction::src_t::CLEANER_TRIM,
-       "trim_journal",
+       Transaction::src_t::CLEANER_TRIM_DIRTY,
+       "trim_dirty",
        [this, seq=std::move(seq)](auto& t)
       {
        return rewrite_dirty(t, seq
@@ -1378,7 +1378,8 @@ void AsyncCleaner::log_gc_state(const char *caller) const
       "alloc_tail_target {}, "
       "dirty_tail_target {}, "
       "tail_limit {}, "
-      "gc_should_trim_journal {}, ",
+      "gc_should_trim_dirty {}, "
+      "gc_should_trim_alloc{}, ",
       caller,
       segments.get_num_empty(),
       segments.get_num_open(),
@@ -1400,7 +1401,8 @@ void AsyncCleaner::log_gc_state(const char *caller) const
       get_alloc_tail_target(),
       get_dirty_tail_target(),
       get_tail_limit(),
-      gc_should_trim_journal()
+      gc_should_trim_dirty(),
+      gc_should_trim_alloc()
     );
   }
 }

diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h
index 7c2bae392bfd2983447cdc2243fef1da61d098df..1ae22517a4b89dbd5dc93e38332bf64c1d934c68 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.h
+++ b/src/crimson/os/seastore/async_cleaner.h
@@ -512,14 +512,14 @@ class AsyncCleaner : public SegmentProvider {
 public:
   /// Config
   struct config_t {
-    /// Number of minimum journal segments to stop trimming.
-    size_t target_journal_segments = 0;
+    /// Number of minimum journal segments to stop trimming dirty.
+    size_t target_journal_dirty_segments = 0;
     /// Number of maximum journal segments to block user transactions.
     size_t max_journal_segments = 0;
 
-    /// Number of journal segments the transactions in which can
-    /// have their corresponding backrefs unmerged
-    size_t target_backref_inflight_segments = 0;
+    /// Number of minimum journal segments to stop trimming allocation
+    /// (having the corresponding backrefs unmerged)
+    size_t target_journal_alloc_segments = 0;
 
     /// Ratio of maximum available space to disable reclaiming.
     double available_ratio_gc_max = 0;
@@ -539,7 +539,8 @@ public:
     size_t rewrite_backref_bytes_per_cycle = 0;
 
     void validate() const {
-      ceph_assert(max_journal_segments > target_journal_segments);
+      ceph_assert(max_journal_segments > target_journal_dirty_segments);
+      ceph_assert(max_journal_segments > target_journal_alloc_segments);
       ceph_assert(available_ratio_gc_max > available_ratio_hard_limit);
       ceph_assert(reclaim_bytes_per_cycle > 0);
       ceph_assert(rewrite_dirty_bytes_per_cycle > 0);
@@ -548,9 +549,9 @@ public:
 
     static config_t get_default() {
       return config_t{
-         12,   // target_journal_segments
+         12,   // target_journal_dirty_segments
          16,   // max_journal_segments
-         2,    // target_backref_inflight_segments
+         2,    // target_journal_alloc_segments
          .15,  // available_ratio_gc_max
          .1,   // available_ratio_hard_limit
          .1,   // reclaim_ratio_gc_threshold
@@ -562,9 +563,9 @@ public:
 
     static config_t get_test() {
       return config_t{
-         2,    // target_journal_segments
+         2,    // target_journal_dirty_segments
          4,    // max_journal_segments
-         2,    // target_backref_inflight_segments
+         2,    // target_journal_alloc_segments
          .99,  // available_ratio_gc_max
          .2,   // available_ratio_hard_limit
          .6,   // reclaim_ratio_gc_threshold
@@ -920,17 +921,17 @@ private:
     Transaction &t,
     journal_seq_t limit);
 
-  using trim_backrefs_iertr = work_iertr;
-  using trim_backrefs_ret = trim_backrefs_iertr::future<journal_seq_t>;
-  trim_backrefs_ret trim_backrefs(
+  using trim_alloc_iertr = work_iertr;
+  using trim_alloc_ret = trim_alloc_iertr::future<journal_seq_t>;
+  trim_alloc_ret trim_alloc(
     Transaction &t,
     journal_seq_t limit);
 
   journal_seq_t get_dirty_tail_target() const {
     auto ret = journal_head;
     ceph_assert(ret != JOURNAL_SEQ_NULL);
-    if (ret.segment_seq >= config.target_journal_segments) {
-      ret.segment_seq -= config.target_journal_segments;
+    if (ret.segment_seq >= config.target_journal_dirty_segments) {
+      ret.segment_seq -= config.target_journal_dirty_segments;
     } else {
       ret.segment_seq = 0;
       ret.offset = P_ADDR_MIN;
@@ -953,8 +954,8 @@ private:
   journal_seq_t get_alloc_tail_target() const {
     auto ret = journal_head;
     ceph_assert(ret != JOURNAL_SEQ_NULL);
-    if (ret.segment_seq >= config.target_backref_inflight_segments) {
-      ret.segment_seq -= config.target_backref_inflight_segments;
+    if (ret.segment_seq >= config.target_journal_alloc_segments) {
+      ret.segment_seq -= config.target_journal_alloc_segments;
     } else {
       ret.segment_seq = 0;
       ret.offset = P_ADDR_MIN;
@@ -1091,13 +1092,13 @@ private:
 
   gc_cycle_ret do_gc_cycle();
 
-  using gc_trim_journal_ertr = gc_ertr;
-  using gc_trim_journal_ret = gc_trim_journal_ertr::future<>;
-  gc_trim_journal_ret gc_trim_journal();
+  using gc_trim_dirty_ertr = gc_ertr;
+  using gc_trim_dirty_ret = gc_trim_dirty_ertr::future<>;
+  gc_trim_dirty_ret gc_trim_dirty();
 
-  using gc_trim_backref_ertr = gc_ertr;
-  using gc_trim_backref_ret = gc_trim_backref_ertr::future<journal_seq_t>;
-  gc_trim_backref_ret gc_trim_backref(journal_seq_t limit);
+  using gc_trim_alloc_ertr = gc_ertr;
+  using gc_trim_alloc_ret = gc_trim_alloc_ertr::future<journal_seq_t>;
+  gc_trim_alloc_ret gc_trim_alloc(journal_seq_t limit);
 
   using gc_reclaim_space_ertr = gc_ertr;
   using gc_reclaim_space_ret = gc_reclaim_space_ertr::future<>;
@@ -1285,16 +1286,11 @@ private:
     );
   }
 
-  /**
-   * gc_should_trim_journal
-   *
-   * Encapsulates logic for whether gc should be reclaiming segment space.
-   */
-  bool gc_should_trim_journal() const {
+  bool gc_should_trim_dirty() const {
     return get_dirty_tail_target() > journal_dirty_tail;
   }
 
-  bool gc_should_trim_backref() const {
+  bool gc_should_trim_alloc() const {
     return get_alloc_tail_target() > journal_alloc_tail;
   }
   /**
@@ -1306,8 +1302,8 @@ private:
     if (disable_trim) return false;
     ceph_assert(init_complete);
     return gc_should_reclaim_space()
-      || gc_should_trim_journal()
-      || gc_should_trim_backref();
+      || gc_should_trim_dirty()
+      || gc_should_trim_alloc();
   }
 
   void init_mark_segment_closed(

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index be7bd75cd0c76348c1bc6c68c7e18a8e0691de1a..ff127f14c47aab324fdf06ee78fc0f90569693e7 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -133,8 +133,8 @@ void Cache::register_metrics()
   std::map<src_t, sm::label_instance> labels_by_src {
     {src_t::MUTATE, sm::label_instance("src", "MUTATE")},
     {src_t::READ, sm::label_instance("src", "READ")},
-    {src_t::CLEANER_TRIM, sm::label_instance("src", "CLEANER_TRIM")},
-    {src_t::TRIM_BACKREF, sm::label_instance("src", "TRIM_BACKREF")},
+    {src_t::CLEANER_TRIM_DIRTY, sm::label_instance("src", "CLEANER_TRIM_DIRTY")},
+    {src_t::CLEANER_TRIM_ALLOC, sm::label_instance("src", "CLEANER_TRIM_ALLOC")},
     {src_t::CLEANER_RECLAIM, sm::label_instance("src", "CLEANER_RECLAIM")},
   };
   assert(labels_by_src.size() == (std::size_t)src_t::MAX);
@@ -622,12 +622,12 @@ void Cache::register_metrics()
       // should be consistent with checks in account_conflict()
       if ((src1 == Transaction::src_t::READ &&
            src2 == Transaction::src_t::READ) ||
-          (src1 == Transaction::src_t::CLEANER_TRIM &&
-           src2 == Transaction::src_t::CLEANER_TRIM) ||
+          (src1 == Transaction::src_t::CLEANER_TRIM_DIRTY &&
+           src2 == Transaction::src_t::CLEANER_TRIM_DIRTY) ||
           (src1 == Transaction::src_t::CLEANER_RECLAIM &&
            src2 == Transaction::src_t::CLEANER_RECLAIM) ||
-          (src1 == Transaction::src_t::TRIM_BACKREF &&
-           src2 == Transaction::src_t::TRIM_BACKREF)) {
+          (src1 == Transaction::src_t::CLEANER_TRIM_ALLOC &&
+           src2 == Transaction::src_t::CLEANER_TRIM_ALLOC)) {
         continue;
       }
       std::ostringstream oss;
@@ -1344,7 +1344,7 @@ record_t Cache::prepare_record(
     (record.size.get_raw_mdlength() - record.get_delta_size());
 
   auto &rewrite_version_stats = t.get_rewrite_version_stats();
-  if (trans_src == Transaction::src_t::CLEANER_TRIM) {
+  if (trans_src == Transaction::src_t::CLEANER_TRIM_DIRTY) {
     stats.committed_dirty_version.increment_stat(rewrite_version_stats);
   } else if (trans_src == Transaction::src_t::CLEANER_RECLAIM) {
     stats.committed_reclaim_version.increment_stat(rewrite_version_stats);

diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h
index 254af8395c4e8603085dce7f1a32eee40ab4f5da..76fb5370896981062700997fac089f52b44bf177 100644 (file)
--- a/src/crimson/os/seastore/cache.h
+++ b/src/crimson/os/seastore/cache.h
@@ -1231,12 +1231,12 @@ private:
     // should be consistent with trans_srcs_invalidated in register_metrics()
     assert(!(src1 == Transaction::src_t::READ &&
              src2 == Transaction::src_t::READ));
-    assert(!(src1 == Transaction::src_t::CLEANER_TRIM &&
-             src2 == Transaction::src_t::CLEANER_TRIM));
+    assert(!(src1 == Transaction::src_t::CLEANER_TRIM_DIRTY &&
+             src2 == Transaction::src_t::CLEANER_TRIM_DIRTY));
     assert(!(src1 == Transaction::src_t::CLEANER_RECLAIM &&
              src2 == Transaction::src_t::CLEANER_RECLAIM));
-    assert(!(src1 == Transaction::src_t::TRIM_BACKREF &&
-             src2 == Transaction::src_t::TRIM_BACKREF));
+    assert(!(src1 == Transaction::src_t::CLEANER_TRIM_ALLOC &&
+             src2 == Transaction::src_t::CLEANER_TRIM_ALLOC));
 
     auto src1_value = static_cast<std::size_t>(src1);
     auto src2_value = static_cast<std::size_t>(src2);

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index a6191f7dfbc561d4c94140b593907924d890d260..21f7e547efda3e491503b5c252312fa55efff3a0 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -316,10 +316,10 @@ std::ostream &operator<<(std::ostream &os, transaction_type_t type)
     return os << "MUTATE";
   case transaction_type_t::READ:
     return os << "READ";
-  case transaction_type_t::CLEANER_TRIM:
-    return os << "CLEANER_TRIM";
-  case transaction_type_t::TRIM_BACKREF:
-    return os << "TRIM_BACKREF";
+  case transaction_type_t::CLEANER_TRIM_DIRTY:
+    return os << "CLEANER_TRIM_DIRTY";
+  case transaction_type_t::CLEANER_TRIM_ALLOC:
+    return os << "CLEANER_TRIM_ALLOC";
   case transaction_type_t::CLEANER_RECLAIM:
     return os << "CLEANER_RECLAIM";
   case transaction_type_t::MAX:

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index c76c85172c61de5c2d07d0fb0f5c944d2e13a4ab..a745f29e30d24056b74fd8a45fcf1cff64da5b46 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -1555,8 +1555,8 @@ std::ostream &operator<<(std::ostream &out, const segment_tail_t &tail);
 enum class transaction_type_t : uint8_t {
   MUTATE = 0,
   READ, // including weak and non-weak read transactions
-  CLEANER_TRIM,
-  TRIM_BACKREF,
+  CLEANER_TRIM_DIRTY,
+  CLEANER_TRIM_ALLOC,
   CLEANER_RECLAIM,
   MAX
 };
@@ -1573,7 +1573,7 @@ constexpr bool is_valid_transaction(transaction_type_t type) {
 }
 
 constexpr bool is_cleaner_transaction(transaction_type_t type) {
-  return (type >= transaction_type_t::CLEANER_TRIM &&
+  return (type >= transaction_type_t::CLEANER_TRIM_DIRTY &&
           type < transaction_type_t::MAX);
 }
 

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index 308346136947c977ea5b5cbdeb5475415e2b53db..a02221de57235051181ea99cb37549cd9dc123a0 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -325,7 +325,7 @@ TransactionManager::submit_transaction(
 TransactionManager::submit_transaction_direct_ret
 TransactionManager::submit_transaction_direct(
   Transaction &tref,
-  std::optional<journal_seq_t> seq_to_trim)
+  std::optional<journal_seq_t> trim_alloc_to)
 {
   LOG_PREFIX(TransactionManager::submit_transaction_direct);
   SUBTRACET(seastore_t, "start", tref);
@@ -358,10 +358,10 @@ TransactionManager::submit_transaction_direct(
   }).si_then([this, FNAME, &tref] {
     SUBTRACET(seastore_t, "about to prepare", tref);
     return tref.get_handle().enter(write_pipeline.prepare);
-  }).si_then([this, FNAME, &tref, seq_to_trim=std::move(seq_to_trim)]() mutable
+  }).si_then([this, FNAME, &tref, trim_alloc_to=std::move(trim_alloc_to)]() mutable
              -> submit_transaction_iertr::future<> {
-    if (seq_to_trim && *seq_to_trim != JOURNAL_SEQ_NULL) {
-      cache->trim_backref_bufs(*seq_to_trim);
+    if (trim_alloc_to && *trim_alloc_to != JOURNAL_SEQ_NULL) {
+      cache->trim_backref_bufs(*trim_alloc_to);
     }
 
     auto record = cache->prepare_record(tref, async_cleaner.get());
@@ -370,8 +370,7 @@ TransactionManager::submit_transaction_direct(
 
     SUBTRACET(seastore_t, "about to submit to journal", tref);
     return journal->submit_record(std::move(record), tref.get_handle()
-    ).safe_then([this, FNAME, &tref, seq_to_trim=std::move(seq_to_trim)]
-      (auto submit_result) mutable {
+    ).safe_then([this, FNAME, &tref](auto submit_result) mutable {
       SUBDEBUGT(seastore_t, "committed with {}", tref, submit_result);
       auto start_seq = submit_result.write_result.start_seq;
       cache->complete_commit(