crimson/os/seastore: rename reclaim_gen_t to rewrite_gen_t

Generation is counting rewrites, not reclaims.

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 819f69e5e2be330c13958f347a5a82ef67b74745..fc0372cdfc834726e7f99bf6d33cf18f62df71e3 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -26,12 +26,12 @@ namespace crimson::os::seastore {
 
 void segment_info_t::set_open(
     segment_seq_t _seq, segment_type_t _type,
-    data_category_t _category, reclaim_gen_t _generation)
+    data_category_t _category, rewrite_gen_t _generation)
 {
   ceph_assert(_seq != NULL_SEG_SEQ);
   ceph_assert(_type != segment_type_t::NULL_SEG);
   ceph_assert(_category != data_category_t::NUM);
-  ceph_assert(is_reclaim_generation(_generation));
+  ceph_assert(is_rewrite_generation(_generation));
   state = Segment::segment_state_t::OPEN;
   seq = _seq;
   type = _type;
@@ -60,13 +60,13 @@ void segment_info_t::set_closed()
 
 void segment_info_t::init_closed(
     segment_seq_t _seq, segment_type_t _type,
-    data_category_t _category, reclaim_gen_t _generation,
+    data_category_t _category, rewrite_gen_t _generation,
     segment_off_t seg_size)
 {
   ceph_assert(_seq != NULL_SEG_SEQ);
   ceph_assert(_type != segment_type_t::NULL_SEG);
   ceph_assert(_category != data_category_t::NUM);
-  ceph_assert(is_reclaim_generation(_generation));
+  ceph_assert(is_rewrite_generation(_generation));
   state = Segment::segment_state_t::CLOSED;
   seq = _seq;
   type = _type;
@@ -86,7 +86,7 @@ std::ostream& operator<<(std::ostream &out, const segment_info_t &info)
     out << " " << info.type
         << " " << segment_seq_printer_t{info.seq}
         << " " << info.category
-        << " " << reclaim_gen_printer_t{info.generation}
+        << " " << rewrite_gen_printer_t{info.generation}
         << ", modify_time=" << sea_time_point_printer_t{info.modify_time}
         << ", num_extents=" << info.num_extents
         << ", written_to=" << info.written_to;
@@ -155,14 +155,14 @@ void segments_info_t::add_segment_manager(
 
 void segments_info_t::init_closed(
     segment_id_t segment, segment_seq_t seq, segment_type_t type,
-    data_category_t category, reclaim_gen_t generation)
+    data_category_t category, rewrite_gen_t generation)
 {
   LOG_PREFIX(segments_info_t::init_closed);
   auto& segment_info = segments[segment];
   DEBUG("initiating {} {} {} {} {}, {}, "
         "num_segments(empty={}, opened={}, closed={})",
         segment, type, segment_seq_printer_t{seq},
-        category, reclaim_gen_printer_t{generation},
+        category, rewrite_gen_printer_t{generation},
         segment_info, num_empty, num_open, num_closed);
   ceph_assert(segment_info.is_empty());
   ceph_assert(num_empty > 0);
@@ -189,14 +189,14 @@ void segments_info_t::init_closed(
 
 void segments_info_t::mark_open(
     segment_id_t segment, segment_seq_t seq, segment_type_t type,
-    data_category_t category, reclaim_gen_t generation)
+    data_category_t category, rewrite_gen_t generation)
 {
   LOG_PREFIX(segments_info_t::mark_open);
   auto& segment_info = segments[segment];
   INFO("opening {} {} {} {} {}, {}, "
        "num_segments(empty={}, opened={}, closed={})",
        segment, type, segment_seq_printer_t{seq},
-       category, reclaim_gen_printer_t{generation},
+       category, rewrite_gen_printer_t{generation},
        segment_info, num_empty, num_open, num_closed);
   ceph_assert(segment_info.is_empty());
   ceph_assert(num_empty > 0);
@@ -923,7 +923,7 @@ segment_id_t SegmentCleaner::allocate_segment(
     segment_seq_t seq,
     segment_type_t type,
     data_category_t category,
-    reclaim_gen_t generation)
+    rewrite_gen_t generation)
 {
   LOG_PREFIX(SegmentCleaner::allocate_segment);
   assert(seq != NULL_SEG_SEQ);
@@ -946,7 +946,7 @@ segment_id_t SegmentCleaner::allocate_segment(
   }
   ERROR("out of space with {} {} {} {}",
         type, segment_seq_printer_t{seq}, category,
-        reclaim_gen_printer_t{generation});
+        rewrite_gen_printer_t{generation});
   ceph_abort();
   return NULL_SEG_ID;
 }
@@ -1120,7 +1120,7 @@ SegmentCleaner::clean_space_ret SegmentCleaner::clean_space()
   reclaim_state->advance(config.reclaim_bytes_per_cycle);
 
   DEBUG("reclaiming {} {}~{}",
-        reclaim_gen_printer_t{reclaim_state->generation},
+        rewrite_gen_printer_t{reclaim_state->generation},
         reclaim_state->start_pos,
         reclaim_state->end_pos);
   double pavail_ratio = get_projected_available_ratio();

diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h
index eb09464e6e41ab067e2779cc39ccc84870d8d08d..8ea00deb759ac15a5f9f28b9cadd01cdddfdc02d 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.h
+++ b/src/crimson/os/seastore/async_cleaner.h
@@ -38,7 +38,7 @@ struct segment_info_t {
 
   data_category_t category = data_category_t::NUM;
 
-  reclaim_gen_t generation = NULL_GENERATION;
+  rewrite_gen_t generation = NULL_GENERATION;
 
   sea_time_point modify_time = NULL_TIME;
 
@@ -64,11 +64,11 @@ struct segment_info_t {
   }
 
   void init_closed(segment_seq_t, segment_type_t,
-                   data_category_t, reclaim_gen_t,
+                   data_category_t, rewrite_gen_t,
                    segment_off_t);
 
   void set_open(segment_seq_t, segment_type_t,
-                data_category_t, reclaim_gen_t);
+                data_category_t, rewrite_gen_t);
 
   void set_empty();
 
@@ -214,10 +214,10 @@ public:
 
   // initiate non-empty segments, the others are by default empty
   void init_closed(segment_id_t, segment_seq_t, segment_type_t,
-                   data_category_t, reclaim_gen_t);
+                   data_category_t, rewrite_gen_t);
 
   void mark_open(segment_id_t, segment_seq_t, segment_type_t,
-                 data_category_t, reclaim_gen_t);
+                 data_category_t, rewrite_gen_t);
 
   void mark_empty(segment_id_t);
 
@@ -328,7 +328,7 @@ public:
   virtual rewrite_extent_ret rewrite_extent(
     Transaction &t,
     CachedExtentRef extent,
-    reclaim_gen_t target_generation,
+    rewrite_gen_t target_generation,
     sea_time_point modify_time) = 0;
 
   /**
@@ -596,7 +596,7 @@ public:
   virtual const segment_info_t& get_seg_info(segment_id_t id) const = 0;
 
   virtual segment_id_t allocate_segment(
-      segment_seq_t, segment_type_t, data_category_t, reclaim_gen_t) = 0;
+      segment_seq_t, segment_type_t, data_category_t, rewrite_gen_t) = 0;
 
   virtual void close_segment(segment_id_t) = 0;
 
@@ -949,7 +949,7 @@ public:
   }
 
   segment_id_t allocate_segment(
-      segment_seq_t, segment_type_t, data_category_t, reclaim_gen_t) final;
+      segment_seq_t, segment_type_t, data_category_t, rewrite_gen_t) final;
 
   void close_segment(segment_id_t segment) final;
 
@@ -1075,19 +1075,19 @@ private:
   segment_id_t get_next_reclaim_segment() const;
 
   struct reclaim_state_t {
-    reclaim_gen_t generation;
-    reclaim_gen_t target_generation;
+    rewrite_gen_t generation;
+    rewrite_gen_t target_generation;
     segment_off_t segment_size;
     paddr_t start_pos;
     paddr_t end_pos;
 
     static reclaim_state_t create(
         segment_id_t segment_id,
-        reclaim_gen_t generation,
+        rewrite_gen_t generation,
         segment_off_t segment_size) {
-      ceph_assert(is_reclaim_generation(generation));
+      ceph_assert(is_rewrite_generation(generation));
 
-      reclaim_gen_t target_gen;
+      rewrite_gen_t target_gen;
       if (generation < MIN_REWRITE_GENERATION) {
         target_gen = MIN_REWRITE_GENERATION;
       } else {
@@ -1096,7 +1096,7 @@ private:
         target_gen = generation + 1;
       }
 
-      assert(is_target_reclaim_generation(target_gen));
+      assert(is_target_rewrite_generation(target_gen));
       return {generation,
               target_gen,
               segment_size,
@@ -1219,7 +1219,7 @@ private:
       segment_seq_t seq,
       segment_type_t s_type,
       data_category_t category,
-      reclaim_gen_t generation) {
+      rewrite_gen_t generation) {
     assert(background_callback->get_state() == state_t::MOUNT);
     ceph_assert(s_type == segment_type_t::OOL ||
                 trimmer != nullptr); // segment_type_t::JOURNAL

diff --git a/src/crimson/os/seastore/btree/fixed_kv_btree.h b/src/crimson/os/seastore/btree/fixed_kv_btree.h
index ccf90caf06be77caa40acb3607288ae3ebf16a31..e851720b1248f745cf144ee6465c8b6279344b15 100644 (file)
--- a/src/crimson/os/seastore/btree/fixed_kv_btree.h
+++ b/src/crimson/os/seastore/btree/fixed_kv_btree.h
@@ -818,8 +818,8 @@ public:
         c.trans,
         fixed_kv_extent.get_length(),
         fixed_kv_extent.get_user_hint(),
-        // get target reclaim generation
-        fixed_kv_extent.get_reclaim_generation());
+        // get target rewrite generation
+        fixed_kv_extent.get_rewrite_generation());
       fixed_kv_extent.get_bptr().copy_out(
         0,
         fixed_kv_extent.get_length(),

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index 1fe91306ba52d271402482d247769c5a33cad60a..4814036e2799e129d3fc4e18d3e79077b2c5a7dc 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -701,7 +701,7 @@ void Cache::add_extent(
 {
   assert(ref->is_valid());
   assert(ref->user_hint == PLACEMENT_HINT_NULL);
-  assert(ref->reclaim_generation == NULL_GENERATION);
+  assert(ref->rewrite_generation == NULL_GENERATION);
   extents.insert(*ref);
   if (ref->is_dirty()) {
     add_to_dirty(ref);
@@ -946,12 +946,12 @@ CachedExtentRef Cache::alloc_new_extent_by_type(
   extent_types_t type,   ///< [in] type tag
   extent_len_t length,   ///< [in] length
   placement_hint_t hint, ///< [in] user hint
-  reclaim_gen_t gen      ///< [in] reclaim generation
+  rewrite_gen_t gen      ///< [in] rewrite generation
 )
 {
   LOG_PREFIX(Cache::alloc_new_extent_by_type);
   SUBDEBUGT(seastore_cache, "allocate {} {}B, hint={}, gen={}",
-            t, type, length, hint, reclaim_gen_printer_t{gen});
+            t, type, length, hint, rewrite_gen_printer_t{gen});
   switch (type) {
   case extent_types_t::ROOT:
     ceph_assert(0 == "ROOT is never directly alloc'd");

diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h
index 7f12f1f3fb9f483ca160c59a571bf78f0283cb26..4fbdfdaa637ee66f8289589ad1fc3fae158cce3c 100644 (file)
--- a/src/crimson/os/seastore/cache.h
+++ b/src/crimson/os/seastore/cache.h
@@ -629,11 +629,11 @@ public:
     Transaction &t,         ///< [in, out] current transaction
     extent_len_t length,    ///< [in] length
     placement_hint_t hint,  ///< [in] user hint
-    reclaim_gen_t gen       ///< [in] reclaim generation
+    rewrite_gen_t gen       ///< [in] rewrite generation
   ) {
     LOG_PREFIX(Cache::alloc_new_extent);
     SUBTRACET(seastore_cache, "allocate {} {}B, hint={}, gen={}",
-              t, T::TYPE, length, hint, reclaim_gen_printer_t{gen});
+              t, T::TYPE, length, hint, rewrite_gen_printer_t{gen});
     auto result = epm.alloc_new_extent(t, T::TYPE, length, hint, gen);
     auto ret = CachedExtent::make_cached_extent_ref<T>(std::move(result.bp));
     ret->init(CachedExtent::extent_state_t::INITIAL_WRITE_PENDING,
@@ -644,7 +644,7 @@ public:
     SUBDEBUGT(seastore_cache,
               "allocated {} {}B extent at {}, hint={}, gen={} -- {}",
               t, T::TYPE, length, result.paddr,
-              hint, reclaim_gen_printer_t{result.gen}, *ret);
+              hint, rewrite_gen_printer_t{result.gen}, *ret);
     return ret;
   }
 
@@ -658,7 +658,7 @@ public:
     extent_types_t type,   ///< [in] type tag
     extent_len_t length,   ///< [in] length
     placement_hint_t hint, ///< [in] user hint
-    reclaim_gen_t gen      ///< [in] reclaim generation
+    rewrite_gen_t gen      ///< [in] rewrite generation
     );
 
   /**

diff --git a/src/crimson/os/seastore/cached_extent.h b/src/crimson/os/seastore/cached_extent.h
index 2024e8115f81031730d91bc6d95479fd4968a388..f7b424a02af300baa467a1029ee15f0840e463cf 100644 (file)
--- a/src/crimson/os/seastore/cached_extent.h
+++ b/src/crimson/os/seastore/cached_extent.h
@@ -117,12 +117,12 @@ public:
   void init(extent_state_t _state,
             paddr_t paddr,
             placement_hint_t hint,
-            reclaim_gen_t gen) {
-    assert(gen == NULL_GENERATION || is_reclaim_generation(gen));
+            rewrite_gen_t gen) {
+    assert(gen == NULL_GENERATION || is_rewrite_generation(gen));
     state = _state;
     set_paddr(paddr);
     user_hint = hint;
-    reclaim_generation = gen;
+    rewrite_generation = gen;
   }
 
   void set_modify_time(sea_time_point t) {
@@ -213,7 +213,7 @@ public:
        << ", last_committed_crc=" << last_committed_crc
        << ", refcount=" << use_count()
        << ", user_hint=" << user_hint
-       << ", reclaim_gen=" << reclaim_gen_printer_t{reclaim_generation};
+       << ", rewrite_gen=" << rewrite_gen_printer_t{rewrite_generation};
     if (state != extent_state_t::INVALID &&
         state != extent_state_t::CLEAN_PENDING) {
       print_detail(out);
@@ -394,21 +394,21 @@ public:
     return user_hint;
   }
 
-  reclaim_gen_t get_reclaim_generation() const {
-    return reclaim_generation;
+  rewrite_gen_t get_rewrite_generation() const {
+    return rewrite_generation;
   }
 
   void invalidate_hints() {
     user_hint = PLACEMENT_HINT_NULL;
-    reclaim_generation = NULL_GENERATION;
+    rewrite_generation = NULL_GENERATION;
   }
 
-  /// assign the target reclaim generation for the followup rewrite
-  void set_target_reclaim_generation(reclaim_gen_t gen) {
-    assert(is_target_reclaim_generation(gen));
+  /// assign the target rewrite generation for the followup rewrite
+  void set_target_rewrite_generation(rewrite_gen_t gen) {
+    assert(is_target_rewrite_generation(gen));
 
     user_hint = placement_hint_t::REWRITE;
-    reclaim_generation = gen;
+    rewrite_generation = gen;
   }
 
   bool is_inline() const {
@@ -490,9 +490,9 @@ private:
 
   placement_hint_t user_hint = PLACEMENT_HINT_NULL;
 
-  // the target reclaim generation for the followup rewrite
-  // or the reclaim generation for the fresh write
-  reclaim_gen_t reclaim_generation = NULL_GENERATION;
+  // the target rewrite generation for the followup rewrite
+  // or the rewrite generation for the fresh write
+  rewrite_gen_t rewrite_generation = NULL_GENERATION;
 
 protected:
   CachedExtent(CachedExtent &&other) = delete;

diff --git a/src/crimson/os/seastore/extent_placement_manager.cc b/src/crimson/os/seastore/extent_placement_manager.cc
index a39b69c32003dfb216ebd99c0dff40317d4fe6da..e6ddaf0a94d68848c2fefc3363ff7ebdc38b737c 100644 (file)
--- a/src/crimson/os/seastore/extent_placement_manager.cc
+++ b/src/crimson/os/seastore/extent_placement_manager.cc
@@ -12,7 +12,7 @@ namespace crimson::os::seastore {
 
 SegmentedOolWriter::SegmentedOolWriter(
   data_category_t category,
-  reclaim_gen_t gen,
+  rewrite_gen_t gen,
   SegmentProvider& sp,
   SegmentSeqAllocator &ssa)
   : segment_allocator(nullptr, category, gen, sp, ssa),
@@ -182,7 +182,7 @@ void ExtentPlacementManager::init(
   ceph_assert(segment_cleaner != nullptr);
   auto num_writers = generation_to_writer(REWRITE_GENERATIONS);
   data_writers_by_gen.resize(num_writers, {});
-  for (reclaim_gen_t gen = OOL_GENERATION; gen < REWRITE_GENERATIONS; ++gen) {
+  for (rewrite_gen_t gen = OOL_GENERATION; gen < REWRITE_GENERATIONS; ++gen) {
     writer_refs.emplace_back(std::make_unique<SegmentedOolWriter>(
           data_category_t::DATA, gen, *segment_cleaner,
           segment_cleaner->get_ool_segment_seq_allocator()));
@@ -190,7 +190,7 @@ void ExtentPlacementManager::init(
   }
 
   md_writers_by_gen.resize(num_writers, {});
-  for (reclaim_gen_t gen = OOL_GENERATION; gen < REWRITE_GENERATIONS; ++gen) {
+  for (rewrite_gen_t gen = OOL_GENERATION; gen < REWRITE_GENERATIONS; ++gen) {
     writer_refs.emplace_back(std::make_unique<SegmentedOolWriter>(
           data_category_t::METADATA, gen, *segment_cleaner,
           segment_cleaner->get_ool_segment_seq_allocator()));
@@ -252,7 +252,7 @@ ExtentPlacementManager::delayed_alloc_or_ool_write(
       auto writer_ptr = get_writer(
           extent->get_user_hint(),
           get_extent_category(extent->get_type()),
-          extent->get_reclaim_generation());
+          extent->get_rewrite_generation());
       alloc_map[writer_ptr].emplace_back(extent);
     }
     return trans_intr::do_for_each(alloc_map, [&t](auto& p) {

diff --git a/src/crimson/os/seastore/extent_placement_manager.h b/src/crimson/os/seastore/extent_placement_manager.h
index d17732e8340ad326210b36d49efa7acf714a6c28..42ae8a89dd269d28afde97999612294796ed2703 100644 (file)
--- a/src/crimson/os/seastore/extent_placement_manager.h
+++ b/src/crimson/os/seastore/extent_placement_manager.h
@@ -47,7 +47,7 @@ using ExtentOolWriterRef = std::unique_ptr<ExtentOolWriter>;
 class SegmentedOolWriter : public ExtentOolWriter {
 public:
   SegmentedOolWriter(data_category_t category,
-                     reclaim_gen_t gen,
+                     rewrite_gen_t gen,
                      SegmentProvider &sp,
                      SegmentSeqAllocator &ssa);
 
@@ -136,17 +136,17 @@ public:
   struct alloc_result_t {
     paddr_t paddr;
     bufferptr bp;
-    reclaim_gen_t gen;
+    rewrite_gen_t gen;
   };
   alloc_result_t alloc_new_extent(
     Transaction& t,
     extent_types_t type,
     extent_len_t length,
     placement_hint_t hint,
-    reclaim_gen_t gen
+    rewrite_gen_t gen
   ) {
     assert(hint < placement_hint_t::NUM_HINTS);
-    assert(is_target_reclaim_generation(gen));
+    assert(is_target_rewrite_generation(gen));
     assert(gen == INIT_GENERATION || hint == placement_hint_t::REWRITE);
 
     // XXX: bp might be extended to point to differnt memory (e.g. PMem)
@@ -265,9 +265,9 @@ private:
 
   ExtentOolWriter* get_writer(placement_hint_t hint,
                               data_category_t category,
-                              reclaim_gen_t gen) {
+                              rewrite_gen_t gen) {
     assert(hint < placement_hint_t::NUM_HINTS);
-    assert(is_reclaim_generation(gen));
+    assert(is_rewrite_generation(gen));
     assert(gen != INLINE_GENERATION);
     if (category == data_category_t::DATA) {
       return data_writers_by_gen[generation_to_writer(gen)];

diff --git a/src/crimson/os/seastore/journal/segment_allocator.cc b/src/crimson/os/seastore/journal/segment_allocator.cc
index 67a362b79dbc001b2d7fbc160621576c03264b69..0018d2f35ca33679a2a39b889adeee6046bdfede 100644 (file)
--- a/src/crimson/os/seastore/journal/segment_allocator.cc
+++ b/src/crimson/os/seastore/journal/segment_allocator.cc
@@ -15,7 +15,7 @@ namespace crimson::os::seastore::journal {
 SegmentAllocator::SegmentAllocator(
   JournalTrimmer *trimmer,
   data_category_t category,
-  reclaim_gen_t gen,
+  rewrite_gen_t gen,
   SegmentProvider &sp,
   SegmentSeqAllocator &ssa)
   : print_name{fmt::format("{}_G{}", category, gen)},

diff --git a/src/crimson/os/seastore/journal/segment_allocator.h b/src/crimson/os/seastore/journal/segment_allocator.h
index acafa5e0d2fbcb6306fc60e134d1b8bb62239647..7faf2e1c45973e79fb0208d3a219a21dfd2c062f 100644 (file)
--- a/src/crimson/os/seastore/journal/segment_allocator.h
+++ b/src/crimson/os/seastore/journal/segment_allocator.h
@@ -33,7 +33,7 @@ class SegmentAllocator {
  public:
   SegmentAllocator(JournalTrimmer *trimmer,
                    data_category_t category,
-                   reclaim_gen_t gen,
+                   rewrite_gen_t gen,
                    SegmentProvider &sp,
                    SegmentSeqAllocator &ssa);
 
@@ -122,7 +122,7 @@ class SegmentAllocator {
   std::string print_name;
   const segment_type_t type; // JOURNAL or OOL
   const data_category_t category;
-  const reclaim_gen_t gen;
+  const rewrite_gen_t gen;
   SegmentProvider &segment_provider;
   SegmentManagerGroup &sm_group;
   SegmentRef current_segment;

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 1b8bab23625e739f28ac09b4eb9d685f21c58524..ef4f7f4e72eab9299bb5143e82ec7251d52ad601 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -246,7 +246,7 @@ std::ostream &operator<<(std::ostream &out, extent_types_t t)
   }
 }
 
-std::ostream &operator<<(std::ostream &out, reclaim_gen_printer_t gen)
+std::ostream &operator<<(std::ostream &out, rewrite_gen_printer_t gen)
 {
   if (gen.gen == NULL_GENERATION) {
     return out << "GEN_NULL";
@@ -349,7 +349,7 @@ std::ostream &operator<<(std::ostream &out, const segment_header_t &header)
              << " " << header.type
              << " " << segment_seq_printer_t{header.segment_seq}
              << " " << header.category
-             << " " << reclaim_gen_printer_t{header.generation}
+             << " " << rewrite_gen_printer_t{header.generation}
              << ", dirty_tail=" << header.dirty_tail
              << ", alloc_tail=" << header.alloc_tail
              << ", segment_nonce=" << header.segment_nonce

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index 490622a67ff16b03d9b9cf8449b2d0762a271f8a..f948d2466f3c903aedce5c3847c3be7494d0a541 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -1118,7 +1118,7 @@ constexpr bool is_backref_node(extent_types_t type)
 std::ostream &operator<<(std::ostream &out, extent_types_t t);
 
 /**
- * reclaim_gen_t
+ * rewrite_gen_t
  *
  * The goal is to group the similar aged extents in the same segment for better
  * bimodel utilization distribution, and also to the same device tier. For EPM,
@@ -1137,16 +1137,16 @@ std::ostream &operator<<(std::ostream &out, extent_types_t t);
  * to not increase the generation if want to keep the hot tier as filled as
  * possible.
  */
-using reclaim_gen_t = uint8_t;
+using rewrite_gen_t = uint8_t;
 
 // INIT_GENERATION requires EPM decision to INLINE/OOL_GENERATION
-constexpr reclaim_gen_t INIT_GENERATION = 0;
-constexpr reclaim_gen_t INLINE_GENERATION = 1; // to the journal
-constexpr reclaim_gen_t OOL_GENERATION = 2;
+constexpr rewrite_gen_t INIT_GENERATION = 0;
+constexpr rewrite_gen_t INLINE_GENERATION = 1; // to the journal
+constexpr rewrite_gen_t OOL_GENERATION = 2;
 
 // All the rewritten extents start with MIN_REWRITE_GENERATION
-constexpr reclaim_gen_t MIN_REWRITE_GENERATION = 3;
-constexpr reclaim_gen_t MAX_REWRITE_GENERATION = 4;
+constexpr rewrite_gen_t MIN_REWRITE_GENERATION = 3;
+constexpr rewrite_gen_t MAX_REWRITE_GENERATION = 4;
 
 /**
  * TODO:
@@ -1154,30 +1154,30 @@ constexpr reclaim_gen_t MAX_REWRITE_GENERATION = 4;
  * hot tier.
  */
 
-constexpr reclaim_gen_t REWRITE_GENERATIONS = MAX_REWRITE_GENERATION + 1;
-constexpr reclaim_gen_t NULL_GENERATION =
-  std::numeric_limits<reclaim_gen_t>::max();
+constexpr rewrite_gen_t REWRITE_GENERATIONS = MAX_REWRITE_GENERATION + 1;
+constexpr rewrite_gen_t NULL_GENERATION =
+  std::numeric_limits<rewrite_gen_t>::max();
 
-struct reclaim_gen_printer_t {
-  reclaim_gen_t gen;
+struct rewrite_gen_printer_t {
+  rewrite_gen_t gen;
 };
 
-std::ostream &operator<<(std::ostream &out, reclaim_gen_printer_t gen);
+std::ostream &operator<<(std::ostream &out, rewrite_gen_printer_t gen);
 
-constexpr std::size_t generation_to_writer(reclaim_gen_t gen) {
+constexpr std::size_t generation_to_writer(rewrite_gen_t gen) {
   // caller to assert the gen is in the reasonable range
   return gen - OOL_GENERATION;
 }
 
 // before EPM decision
-constexpr bool is_target_reclaim_generation(reclaim_gen_t gen) {
+constexpr bool is_target_rewrite_generation(rewrite_gen_t gen) {
   return gen == INIT_GENERATION ||
          (gen >= MIN_REWRITE_GENERATION &&
           gen <= REWRITE_GENERATIONS);
 }
 
 // after EPM decision
-constexpr bool is_reclaim_generation(reclaim_gen_t gen) {
+constexpr bool is_rewrite_generation(rewrite_gen_t gen) {
   return gen >= INLINE_GENERATION &&
          gen < REWRITE_GENERATIONS;
 }
@@ -1694,7 +1694,7 @@ struct segment_header_t {
   segment_type_t type;
 
   data_category_t category;
-  reclaim_gen_t generation;
+  rewrite_gen_t generation;
 
   segment_type_t get_type() const {
     return type;

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index f4ad79803e94cf0faaea83828bcda44e0e90f2e3..794a073f83461953468dfef0f685febad59bb933 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -451,8 +451,8 @@ TransactionManager::rewrite_logical_extent(
     lextent->get_type(),
     lextent->get_length(),
     lextent->get_user_hint(),
-    // get target reclaim generation
-    lextent->get_reclaim_generation())->cast<LogicalCachedExtent>();
+    // get target rewrite generation
+    lextent->get_rewrite_generation())->cast<LogicalCachedExtent>();
   lextent->get_bptr().copy_out(
     0,
     lextent->get_length(),
@@ -477,7 +477,7 @@ TransactionManager::rewrite_logical_extent(
 TransactionManager::rewrite_extent_ret TransactionManager::rewrite_extent(
   Transaction &t,
   CachedExtentRef extent,
-  reclaim_gen_t target_generation,
+  rewrite_gen_t target_generation,
   sea_time_point modify_time)
 {
   LOG_PREFIX(TransactionManager::rewrite_extent);
@@ -494,9 +494,9 @@ TransactionManager::rewrite_extent_ret TransactionManager::rewrite_extent(
 
   assert(extent->is_valid() && !extent->is_initial_pending());
   if (extent->is_dirty()) {
-    extent->set_target_reclaim_generation(INIT_GENERATION);
+    extent->set_target_rewrite_generation(INIT_GENERATION);
   } else {
-    extent->set_target_reclaim_generation(target_generation);
+    extent->set_target_rewrite_generation(target_generation);
     ceph_assert(modify_time != NULL_TIME);
     extent->set_modify_time(modify_time);
   }

diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h
index 6e6eb45f73ca79549030913fe503038fa97a1b5c..cc431ff37d6ce01534f43b3479ab5a3f01fc6d4a 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.h
+++ b/src/crimson/os/seastore/transaction_manager.h
@@ -486,7 +486,7 @@ public:
   rewrite_extent_ret rewrite_extent(
     Transaction &t,
     CachedExtentRef extent,
-    reclaim_gen_t target_generation,
+    rewrite_gen_t target_generation,
     sea_time_point modify_time) final;
 
   using ExtentCallbackInterface::get_extents_if_live_ret;

diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc
index bddb5a13ed93530224210ed416b37931e0c64078..fc510239ac2c7e3b69b0ba64248335d48cf42af6 100644 (file)
--- a/src/test/crimson/seastore/test_btree_lba_manager.cc
+++ b/src/test/crimson/seastore/test_btree_lba_manager.cc
@@ -75,7 +75,7 @@ struct btree_test_base :
     segment_seq_t seq,
     segment_type_t type,
     data_category_t,
-    reclaim_gen_t
+    rewrite_gen_t
   ) final {
     auto ret = next;
     next = segment_id_t{

diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc
index 29a0ca2d0609ca7c1c071bce4cc42f66a491dc57..7b72d7cff9ceff10bbd9b71eafb519f3e7275e1e 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_journal.cc
+++ b/src/test/crimson/seastore/test_seastore_journal.cc
@@ -114,7 +114,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider, JournalTrimmer {
     segment_seq_t seq,
     segment_type_t type,
     data_category_t,
-    reclaim_gen_t
+    rewrite_gen_t
   ) final {
     auto ret = next;
     next = segment_id_t{