crimson/os/seastore/backref: rename BackrefManager::batch_insert_from_cache to Backre...

Signed-off-by: Xuehan Xu <xxhdx1985126@gmail.com>

diff --git a/src/crimson/os/seastore/backref/btree_backref_manager.cc b/src/crimson/os/seastore/backref/btree_backref_manager.cc
index b4acf43bc197819aabf5d5d28998ebbed5d42adc..de2f14f8ac074042fa1a5fd6d3740d37d1426efb 100644 (file)
--- a/src/crimson/os/seastore/backref/btree_backref_manager.cc
+++ b/src/crimson/os/seastore/backref/btree_backref_manager.cc
@@ -203,13 +203,13 @@ BtreeBackrefManager::new_mapping(
     });
 }
 
-BtreeBackrefManager::batch_insert_ret
-BtreeBackrefManager::batch_insert_from_cache(
+BtreeBackrefManager::merge_cached_backrefs_ret
+BtreeBackrefManager::merge_cached_backrefs(
   Transaction &t,
   const journal_seq_t &limit,
   const uint64_t max)
 {
-  LOG_PREFIX(BtreeBackrefManager::batch_insert_from_cache);
+  LOG_PREFIX(BtreeBackrefManager::merge_cached_backrefs);
   DEBUGT("insert up to {}", t, limit);
   return seastar::do_with(
     limit,
@@ -217,19 +217,64 @@ BtreeBackrefManager::batch_insert_from_cache(
     [this, &t, max](auto &limit, auto &inserted_to) {
     auto &backref_buffer = cache.get_backref_buffer();
     if (backref_buffer) {
-      return batch_insert(
-       t,
-       backref_buffer,
-       limit,
-       max
-      ).si_then([&inserted_to](auto new_inserted_to) {
-       assert(inserted_to == JOURNAL_SEQ_NULL
-         || new_inserted_to >= inserted_to);
-       return seastar::make_ready_future<journal_seq_t>(
-         std::move(new_inserted_to));
+      return seastar::do_with(
+       backref_buffer->backrefs.begin(),
+       JOURNAL_SEQ_NULL,
+       [this, &t, &limit, &backref_buffer, max](auto &iter, auto &inserted_to) {
+       return trans_intr::repeat(
+         [&iter, this, &t, &limit, &backref_buffer, max, &inserted_to]()
+         -> merge_cached_backrefs_iertr::future<seastar::stop_iteration> {
+         if (iter == backref_buffer->backrefs.end())
+           return seastar::make_ready_future<seastar::stop_iteration>(
+             seastar::stop_iteration::yes);
+         auto &seq = iter->first;
+         auto &backref_list = iter->second;
+         LOG_PREFIX(BtreeBackrefManager::merge_cached_backrefs);
+         DEBUGT("seq {}, limit {}, num_fresh_backref {}"
+           , t, seq, limit, t.get_num_fresh_backref());
+         if (seq <= limit && t.get_num_fresh_backref() * BACKREF_NODE_SIZE < max) {
+           inserted_to = seq;
+           return trans_intr::do_for_each(
+             backref_list,
+             [this, &t](auto &backref) {
+             LOG_PREFIX(BtreeBackrefManager::merge_cached_backrefs);
+             if (backref->laddr != L_ADDR_NULL) {
+               DEBUGT("new mapping: {}~{} -> {}",
+                 t, backref->paddr, backref->len, backref->laddr);
+               return new_mapping(
+                 t,
+                 backref->paddr,
+                 backref->len,
+                 backref->laddr,
+                 backref->type).si_then([](auto &&pin) {
+                 return seastar::now();
+               });
+             } else {
+               DEBUGT("remove mapping: {}", t, backref->paddr);
+               return remove_mapping(
+                 t,
+                 backref->paddr).si_then([](auto&&) {
+                 return seastar::now();
+               }).handle_error_interruptible(
+                 crimson::ct_error::input_output_error::pass_further(),
+                 crimson::ct_error::assert_all("no enoent possible")
+               );
+             }
+           }).si_then([&iter] {
+             iter++;
+             return seastar::make_ready_future<seastar::stop_iteration>(
+               seastar::stop_iteration::no);
+           });
+         }
+         return seastar::make_ready_future<seastar::stop_iteration>(
+           seastar::stop_iteration::yes);
+       }).si_then([&inserted_to] {
+         return seastar::make_ready_future<journal_seq_t>(
+           std::move(inserted_to));
+       });
       });
     }
-    return batch_insert_iertr::make_ready_future<journal_seq_t>(
+    return merge_cached_backrefs_iertr::make_ready_future<journal_seq_t>(
       std::move(inserted_to));
   });
 }
@@ -272,71 +317,6 @@ BtreeBackrefManager::scan_mapped_space(
     });
 }
 
-BtreeBackrefManager::batch_insert_ret
-BtreeBackrefManager::batch_insert(
-  Transaction &t,
-  backref_buffer_ref &bbr,
-  const journal_seq_t &limit,
-  const uint64_t max)
-{
-  return seastar::do_with(
-    bbr->backrefs.begin(),
-    JOURNAL_SEQ_NULL,
-    [this, &t, &limit, &bbr, max](auto &iter, auto &inserted_to) {
-    return trans_intr::repeat(
-      [&iter, this, &t, &limit, &bbr, max, &inserted_to]()
-      -> batch_insert_iertr::future<seastar::stop_iteration> {
-      if (iter == bbr->backrefs.end())
-       return seastar::make_ready_future<seastar::stop_iteration>(
-         seastar::stop_iteration::yes);
-      auto &seq = iter->first;
-      auto &backref_list = iter->second;
-      LOG_PREFIX(BtreeBackrefManager::batch_insert);
-      DEBUGT("seq {}, limit {}, num_fresh_backref {}"
-       , t, seq, limit, t.get_num_fresh_backref());
-      if (seq <= limit && t.get_num_fresh_backref() * BACKREF_NODE_SIZE < max) {
-       inserted_to = seq;
-       return trans_intr::do_for_each(
-         backref_list,
-         [this, &t](auto &backref) {
-         LOG_PREFIX(BtreeBackrefManager::batch_insert);
-         if (backref->laddr != L_ADDR_NULL) {
-           DEBUGT("new mapping: {}~{} -> {}",
-             t, backref->paddr, backref->len, backref->laddr);
-           return new_mapping(
-             t,
-             backref->paddr,
-             backref->len,
-             backref->laddr,
-             backref->type).si_then([](auto &&pin) {
-             return seastar::now();
-           });
-         } else {
-           DEBUGT("remove mapping: {}", t, backref->paddr);
-           return remove_mapping(
-             t,
-             backref->paddr).si_then([](auto&&) {
-             return seastar::now();
-           }).handle_error_interruptible(
-             crimson::ct_error::input_output_error::pass_further(),
-             crimson::ct_error::assert_all("no enoent possible")
-           );
-         }
-       }).si_then([&iter] {
-         iter++;
-         return seastar::make_ready_future<seastar::stop_iteration>(
-           seastar::stop_iteration::no);
-       });
-      }
-      return seastar::make_ready_future<seastar::stop_iteration>(
-       seastar::stop_iteration::yes);
-    }).si_then([&inserted_to] {
-      return seastar::make_ready_future<journal_seq_t>(
-       std::move(inserted_to));
-    });
-  });
-}
-
 BtreeBackrefManager::base_iertr::future<> _init_cached_extent(
   op_context_t<paddr_t> c,
   const CachedExtentRef &e,

diff --git a/src/crimson/os/seastore/backref/btree_backref_manager.h b/src/crimson/os/seastore/backref/btree_backref_manager.h
index 4a48b475759a5f8521604527e78b98aa882cf74d..0a3395270378d80c292a1e79325aa7166d1b84f1 100644 (file)
--- a/src/crimson/os/seastore/backref/btree_backref_manager.h
+++ b/src/crimson/os/seastore/backref/btree_backref_manager.h
@@ -64,13 +64,7 @@ public:
     laddr_t val,
     extent_types_t type) final;
 
-  batch_insert_ret batch_insert(
-    Transaction &t,
-    backref_buffer_ref &bbr,
-    const journal_seq_t &limit,
-    const uint64_t max) final;
-
-  batch_insert_ret batch_insert_from_cache(
+  merge_cached_backrefs_ret merge_cached_backrefs(
     Transaction &t,
     const journal_seq_t &limit,
     const uint64_t max) final;

diff --git a/src/crimson/os/seastore/backref_manager.h b/src/crimson/os/seastore/backref_manager.h
index d1ba4b954c9b509fb3d2a0b1421266754324256f..ab9d5108b89bd7133bb5356ad09b281c2c574b77 100644 (file)
--- a/src/crimson/os/seastore/backref_manager.h
+++ b/src/crimson/os/seastore/backref_manager.h
@@ -83,20 +83,6 @@ public:
     Transaction &t,
     CachedExtentRef e) = 0;
 
-  /**
-   * insert new paddr_t -> laddr_t mappings in batches
-   */
-  using batch_insert_iertr = base_iertr;
-  using batch_insert_ret = batch_insert_iertr::future<journal_seq_t>;
-  virtual batch_insert_ret batch_insert(
-    Transaction &t,                    ///< Transaction that commits the updates
-    backref_buffer_ref &bbr,           ///< the set of backref mappings to be inserted
-    const journal_seq_t &limit,                ///< the journal seq upper bound that the insertion
-                                       //   shouldn't cross
-    const uint64_t max                 ///< maximum fresh backref extents that can be
-                                       //   created by this insertion
-  ) = 0;
-
   virtual Cache::backref_buf_entry_query_set_t
   get_cached_backrefs_in_range(
     paddr_t start,
@@ -130,9 +116,11 @@ public:
   virtual void cache_new_backref_extent(paddr_t paddr, extent_types_t type) = 0;
 
   /**
-   * insert new mappings directly from Cache
+   * merge in-cache paddr_t -> laddr_t mappings to the on-disk backref tree
    */
-  virtual batch_insert_ret batch_insert_from_cache(
+  using merge_cached_backrefs_iertr = base_iertr;
+  using merge_cached_backrefs_ret = merge_cached_backrefs_iertr::future<journal_seq_t>;
+  virtual merge_cached_backrefs_ret merge_cached_backrefs(
     Transaction &t,
     const journal_seq_t &limit,
     const uint64_t max) = 0;

diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/segment_cleaner.cc
index 14f1ddfa4be34d944da3be515a1cf5b6ec8e055c..df5ccdf8d688f6a1fa30ffb3049b270ced6e3532 100644 (file)
--- a/src/crimson/os/seastore/segment_cleaner.cc
+++ b/src/crimson/os/seastore/segment_cleaner.cc
@@ -652,7 +652,7 @@ SegmentCleaner::trim_backrefs_ret SegmentCleaner::trim_backrefs(
   Transaction &t,
   journal_seq_t limit)
 {
-  return backref_manager.batch_insert_from_cache(
+  return backref_manager.merge_cached_backrefs(
     t,
     limit,
     config.rewrite_backref_bytes_per_cycle
@@ -930,12 +930,12 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space()
                }).si_then([this, &seq, &t](auto nseq) {
                  if (nseq != JOURNAL_SEQ_NULL && nseq > seq)
                    seq = nseq;
-                 auto fut = BackrefManager::batch_insert_iertr::now();
+                 auto fut = BackrefManager::merge_cached_backrefs_iertr::now();
                  if (seq != JOURNAL_SEQ_NULL) {
-                   fut = backref_manager.batch_insert_from_cache(
+                   fut = backref_manager.merge_cached_backrefs(
                      t, seq, std::numeric_limits<uint64_t>::max()
                    ).si_then([](auto) {
-                     return BackrefManager::batch_insert_iertr::now();
+                     return BackrefManager::merge_cached_backrefs_iertr::now();
                    });
                  }
                  return fut;