From: Xuehan Xu Date: Tue, 15 Jul 2025 06:22:16 +0000 (+0800) Subject: crimson/os/seastore/extent_placement_manager: make MIN_COLD_GENERATION X-Git-Tag: testing/wip-vshankar-testing-20250805.100115-debug~41^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=15dbdd65de74ffd0a907bf72ccb1dc5807724960;p=ceph-ci.git crimson/os/seastore/extent_placement_manager: make MIN_COLD_GENERATION and MAX_REWRITE_GENERATION configurable Signed-off-by: Xuehan Xu --- diff --git a/src/common/options/crimson.yaml.in b/src/common/options/crimson.yaml.in index 5999758e229..1d26d42c706 100644 --- a/src/common/options/crimson.yaml.in +++ b/src/common/options/crimson.yaml.in @@ -189,6 +189,16 @@ options: level: advanced desc: Begin fast eviction when the used ratio of the main tier reaches this value. default: 0.7 +- name: seastore_hot_tier_generations + type: uint + level: advanced + desc: The number of generations in the hot tier or the whole SeaStore instance if there's only one tier. + default: 5 +- name: seastore_cold_tier_generations + type: uint + level: advanced + desc: The number of generations in the cold tier if it exists. + default: 3 - name: seastore_data_delta_based_overwrite type: size level: dev diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc index bc1d19afd48..52ed20415c7 100644 --- a/src/crimson/os/seastore/async_cleaner.cc +++ b/src/crimson/os/seastore/async_cleaner.cc @@ -32,7 +32,6 @@ void segment_info_t::set_open( ceph_assert(_seq != NULL_SEG_SEQ); ceph_assert(_type != segment_type_t::NULL_SEG); ceph_assert(_category != data_category_t::NUM); - ceph_assert(is_rewrite_generation(_generation)); state = Segment::segment_state_t::OPEN; seq = _seq; type = _type; @@ -67,7 +66,6 @@ void segment_info_t::init_closed( ceph_assert(_seq != NULL_SEG_SEQ); ceph_assert(_type != segment_type_t::NULL_SEG); ceph_assert(_category != data_category_t::NUM); - ceph_assert(is_rewrite_generation(_generation)); state = Segment::segment_state_t::CLOSED; seq = _seq; type = _type; @@ -916,6 +914,7 @@ SegmentCleaner::SegmentCleaner( SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, SegmentSeqAllocator &segment_seq_allocator, + rewrite_gen_t max_rewrite_generation, bool detailed, bool is_cold) : detailed(detailed), @@ -923,7 +922,8 @@ SegmentCleaner::SegmentCleaner( config(config), sm_group(std::move(sm_group)), backref_manager(backref_manager), - ool_segment_seq_allocator(segment_seq_allocator) + ool_segment_seq_allocator(segment_seq_allocator), + max_rewrite_generation(max_rewrite_generation) { config.validate(); } @@ -1060,6 +1060,7 @@ segment_id_t SegmentCleaner::allocate_segment( auto& segment_info = it->second; if (segment_info.is_empty()) { auto old_usage = calc_utilization(seg_id); + ceph_assert(is_rewrite_generation(generation, max_rewrite_generation)); segments.mark_open(seg_id, seq, type, category, generation); if (type == segment_type_t::JOURNAL) { assert(trimmer != nullptr); @@ -1271,8 +1272,12 @@ SegmentCleaner::clean_space_ret SegmentCleaner::clean_space() space_tracker->calc_utilization(seg_id), sea_time_point_printer_t{segments.get_time_bound()}); ceph_assert(segment_info.is_closed()); + ceph_assert(is_rewrite_generation( + segment_info.generation, max_rewrite_generation)); reclaim_state = reclaim_state_t::create( seg_id, segment_info.generation, segments.get_segment_size()); + assert(is_target_rewrite_generation( + reclaim_state->target_generation, max_rewrite_generation)); } reclaim_state->advance(config.reclaim_bytes_per_cycle); diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h index 72460c7c76c..7e99dda95e7 100644 --- a/src/crimson/os/seastore/async_cleaner.h +++ b/src/crimson/os/seastore/async_cleaner.h @@ -1291,6 +1291,7 @@ public: SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, SegmentSeqAllocator &segment_seq_allocator, + rewrite_gen_t max_rewrite_generation, bool detailed, bool is_cold); @@ -1303,11 +1304,13 @@ public: SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, SegmentSeqAllocator &ool_seq_allocator, + rewrite_gen_t max_rewrite_generation, bool detailed, bool is_cold = false) { return std::make_unique( config, std::move(sm_group), backref_manager, - ool_seq_allocator, detailed, is_cold); + ool_seq_allocator, max_rewrite_generation, + detailed, is_cold); } /* @@ -1472,7 +1475,6 @@ private: segment_id_t segment_id, rewrite_gen_t generation, segment_off_t segment_size) { - ceph_assert(is_rewrite_generation(generation)); rewrite_gen_t target_gen; if (generation < MIN_REWRITE_GENERATION) { @@ -1483,7 +1485,6 @@ private: target_gen = generation + 1; } - assert(is_target_rewrite_generation(target_gen)); return {generation, target_gen, segment_size, @@ -1611,6 +1612,7 @@ private: ceph_assert(s_type == segment_type_t::OOL || trimmer != nullptr); // segment_type_t::JOURNAL auto old_usage = calc_utilization(segment); + ceph_assert(is_rewrite_generation(generation, max_rewrite_generation)); segments.init_closed(segment, seq, s_type, category, generation); auto new_usage = calc_utilization(segment); adjust_segment_util(old_usage, new_usage); @@ -1670,6 +1672,7 @@ private: // TODO: drop once paddr->journal_seq_t is introduced SegmentSeqAllocator &ool_segment_seq_allocator; + const rewrite_gen_t max_rewrite_generation = NULL_GENERATION; }; class RBMCleaner; diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h index 8aee2553287..0dacd80bcad 100644 --- a/src/crimson/os/seastore/cache.h +++ b/src/crimson/os/seastore/cache.h @@ -1115,6 +1115,9 @@ public: std::rethrow_exception(crimson::ct_error::enospc::exception_ptr()); } auto ret = CachedExtent::make_cached_extent_ref(std::move(result->bp)); + assert(is_rewrite_generation( + result->gen, + epm.dynamic_max_rewrite_generation)); ret->init(CachedExtent::extent_state_t::INITIAL_WRITE_PENDING, result->paddr, hint, @@ -1160,6 +1163,9 @@ public: std::vector> extents; for (auto &result : results) { auto ret = CachedExtent::make_cached_extent_ref(std::move(result.bp)); + assert(is_rewrite_generation( + result.gen, + epm.dynamic_max_rewrite_generation)); ret->init(CachedExtent::extent_state_t::INITIAL_WRITE_PENDING, result.paddr, hint, diff --git a/src/crimson/os/seastore/cached_extent.h b/src/crimson/os/seastore/cached_extent.h index 10c4aa704c8..4cc8f799490 100644 --- a/src/crimson/os/seastore/cached_extent.h +++ b/src/crimson/os/seastore/cached_extent.h @@ -311,7 +311,6 @@ public: placement_hint_t hint, rewrite_gen_t gen, transaction_id_t trans_id) { - assert(gen == NULL_GENERATION || is_rewrite_generation(gen)); state = _state; set_paddr(paddr); user_hint = hint; @@ -758,8 +757,6 @@ public: /// 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; rewrite_generation = gen; } diff --git a/src/crimson/os/seastore/extent_placement_manager.cc b/src/crimson/os/seastore/extent_placement_manager.cc index 457cd1cf1dc..445c7b62f91 100644 --- a/src/crimson/os/seastore/extent_placement_manager.cc +++ b/src/crimson/os/seastore/extent_placement_manager.cc @@ -193,10 +193,11 @@ void ExtentPlacementManager::init( { writer_refs.clear(); auto cold_segment_cleaner = dynamic_cast(cold_cleaner.get()); - dynamic_max_rewrite_generation = MIN_COLD_GENERATION - 1; + dynamic_max_rewrite_generation = hot_tier_generations - 1; if (cold_segment_cleaner) { - dynamic_max_rewrite_generation = MAX_REWRITE_GENERATION; + dynamic_max_rewrite_generation = hot_tier_generations + cold_tier_generations - 1; } + ceph_assert(dynamic_max_rewrite_generation > MIN_REWRITE_GENERATION); if (trimmer->get_backend_type() == backend_type_t::SEGMENTED) { auto segment_cleaner = dynamic_cast(cleaner.get()); @@ -204,7 +205,7 @@ void ExtentPlacementManager::init( auto num_writers = generation_to_writer(dynamic_max_rewrite_generation + 1); data_writers_by_gen.resize(num_writers, nullptr); - for (rewrite_gen_t gen = OOL_GENERATION; gen < MIN_COLD_GENERATION; ++gen) { + for (rewrite_gen_t gen = OOL_GENERATION; gen < hot_tier_generations; ++gen) { writer_refs.emplace_back(std::make_unique( data_category_t::DATA, gen, *segment_cleaner, *ool_segment_seq_allocator)); @@ -212,7 +213,7 @@ void ExtentPlacementManager::init( } md_writers_by_gen.resize(num_writers, {}); - for (rewrite_gen_t gen = OOL_GENERATION; gen < MIN_COLD_GENERATION; ++gen) { + for (rewrite_gen_t gen = OOL_GENERATION; gen < hot_tier_generations; ++gen) { writer_refs.emplace_back(std::make_unique( data_category_t::METADATA, gen, *segment_cleaner, *ool_segment_seq_allocator)); @@ -241,13 +242,13 @@ void ExtentPlacementManager::init( } if (cold_segment_cleaner) { - for (rewrite_gen_t gen = MIN_COLD_GENERATION; gen < REWRITE_GENERATIONS; ++gen) { + for (rewrite_gen_t gen = hot_tier_generations; gen <= dynamic_max_rewrite_generation; ++gen) { writer_refs.emplace_back(std::make_unique( data_category_t::DATA, gen, *cold_segment_cleaner, *ool_segment_seq_allocator)); data_writers_by_gen[generation_to_writer(gen)] = writer_refs.back().get(); } - for (rewrite_gen_t gen = MIN_COLD_GENERATION; gen < REWRITE_GENERATIONS; ++gen) { + for (rewrite_gen_t gen = hot_tier_generations; gen <= dynamic_max_rewrite_generation; ++gen) { writer_refs.emplace_back(std::make_unique( data_category_t::METADATA, gen, *cold_segment_cleaner, *ool_segment_seq_allocator)); @@ -261,7 +262,8 @@ void ExtentPlacementManager::init( background_process.init(std::move(trimmer), std::move(cleaner), - std::move(cold_cleaner)); + std::move(cold_cleaner), + hot_tier_generations); if (cold_segment_cleaner) { ceph_assert(get_main_backend_type() == backend_type_t::SEGMENTED); ceph_assert(background_process.has_cold_tier()); @@ -304,7 +306,7 @@ ExtentPlacementManager::get_device_stats( main_stats.add(main_writer_stats.back()); // 2. mainmdat main_writer_stats.emplace_back(); - for (rewrite_gen_t gen = MIN_REWRITE_GENERATION; gen < MIN_COLD_GENERATION; ++gen) { + for (rewrite_gen_t gen = MIN_REWRITE_GENERATION; gen < hot_tier_generations; ++gen) { const auto &writer = get_writer(METADATA, gen); ceph_assert(writer->get_type() == backend_type_t::SEGMENTED); main_writer_stats.back().add(writer->get_stats()); @@ -312,7 +314,7 @@ ExtentPlacementManager::get_device_stats( main_stats.add(main_writer_stats.back()); // 3. maindata main_writer_stats.emplace_back(); - for (rewrite_gen_t gen = MIN_REWRITE_GENERATION; gen < MIN_COLD_GENERATION; ++gen) { + for (rewrite_gen_t gen = MIN_REWRITE_GENERATION; gen < hot_tier_generations; ++gen) { const auto &writer = get_writer(DATA, gen); ceph_assert(writer->get_type() == backend_type_t::SEGMENTED); main_writer_stats.back().add(writer->get_stats()); @@ -333,7 +335,9 @@ ExtentPlacementManager::get_device_stats( if (has_cold_tier) { // 0. coldmdat cold_writer_stats.emplace_back(); - for (rewrite_gen_t gen = MIN_COLD_GENERATION; gen < REWRITE_GENERATIONS; ++gen) { + for (rewrite_gen_t gen = hot_tier_generations; + gen <= dynamic_max_rewrite_generation; + ++gen) { const auto &writer = get_writer(METADATA, gen); ceph_assert(writer->get_type() == backend_type_t::SEGMENTED); cold_writer_stats.back().add(writer->get_stats()); @@ -341,7 +345,9 @@ ExtentPlacementManager::get_device_stats( cold_stats.add(cold_writer_stats.back()); // 1. colddata cold_writer_stats.emplace_back(); - for (rewrite_gen_t gen = MIN_COLD_GENERATION; gen < REWRITE_GENERATIONS; ++gen) { + for (rewrite_gen_t gen = hot_tier_generations; + gen <= dynamic_max_rewrite_generation; + ++gen) { const auto &writer = get_writer(DATA, gen); ceph_assert(writer->get_type() == backend_type_t::SEGMENTED); cold_writer_stats.back().add(writer->get_stats()); @@ -465,7 +471,7 @@ ExtentPlacementManager::dispatch_delayed_extents(Transaction &t) res.usage.cleaner_usage.main_usage += extent->get_length(); t.mark_delayed_extent_inline(extent); } else { - if (extent->get_rewrite_generation() < MIN_COLD_GENERATION) { + if (extent->get_rewrite_generation() < hot_tier_generations) { res.usage.cleaner_usage.main_usage += extent->get_length(); } else { assert(background_process.has_cold_tier()); diff --git a/src/crimson/os/seastore/extent_placement_manager.h b/src/crimson/os/seastore/extent_placement_manager.h index 913e95ab647..63b36346183 100644 --- a/src/crimson/os/seastore/extent_placement_manager.h +++ b/src/crimson/os/seastore/extent_placement_manager.h @@ -19,6 +19,8 @@ class transaction_manager_test_t; namespace crimson::os::seastore { +class Cache; + /** * ExtentOolWriter * @@ -255,13 +257,21 @@ struct reserve_io_result_t { class ExtentPlacementManager { public: - ExtentPlacementManager() - : ool_segment_seq_allocator( + ExtentPlacementManager( + rewrite_gen_t hot_tier_generations, + rewrite_gen_t cold_tier_generations) + : hot_tier_generations(hot_tier_generations), + cold_tier_generations(cold_tier_generations), + dynamic_max_rewrite_generation(cold_tier_generations), + ool_segment_seq_allocator( std::make_unique(segment_type_t::OOL)), max_data_allocation_size(crimson::common::get_conf( "seastore_max_data_allocation_size")) { + LOG_PREFIX(ExtentPlacementManager::ExtentPlacementManager); devices_by_id.resize(DEVICE_ID_MAX, nullptr); + SUBINFO(seastore_epm, "cold_tier_generations={}, hot_tier_generations={}", + cold_tier_generations, hot_tier_generations); } void init(JournalTrimmerImplRef &&, AsyncCleanerRef &&, AsyncCleanerRef &&); @@ -343,7 +353,7 @@ public: #endif ) { assert(hint < placement_hint_t::NUM_HINTS); - assert(is_target_rewrite_generation(gen)); + assert(is_target_rewrite_generation(gen, dynamic_max_rewrite_generation)); assert(gen == INIT_GENERATION || hint == placement_hint_t::REWRITE); data_category_t category = get_extent_category(type); @@ -390,7 +400,7 @@ public: ) { LOG_PREFIX(ExtentPlacementManager::alloc_new_data_extents); assert(hint < placement_hint_t::NUM_HINTS); - assert(is_target_rewrite_generation(gen)); + assert(is_target_rewrite_generation(gen, dynamic_max_rewrite_generation)); assert(gen == INIT_GENERATION || hint == placement_hint_t::REWRITE); data_category_t category = get_extent_category(type); @@ -582,7 +592,7 @@ private: } else if (hint == placement_hint_t::COLD) { assert(gen == INIT_GENERATION); if (background_process.has_cold_tier()) { - gen = MIN_COLD_GENERATION; + gen = hot_tier_generations; } else { gen = MIN_REWRITE_GENERATION; } @@ -643,7 +653,7 @@ private: ExtentOolWriter* get_writer(data_category_t category, rewrite_gen_t gen) { - assert(is_rewrite_generation(gen)); + assert(is_rewrite_generation(gen, dynamic_max_rewrite_generation)); assert(gen != INLINE_GENERATION); assert(gen <= dynamic_max_rewrite_generation); ExtentOolWriter* ret = nullptr; @@ -659,7 +669,7 @@ private: const ExtentOolWriter* get_writer(data_category_t category, rewrite_gen_t gen) const { - assert(is_rewrite_generation(gen)); + assert(is_rewrite_generation(gen, dynamic_max_rewrite_generation)); assert(gen != INLINE_GENERATION); assert(gen <= dynamic_max_rewrite_generation); ExtentOolWriter* ret = nullptr; @@ -686,7 +696,8 @@ private: void init(JournalTrimmerImplRef &&_trimmer, AsyncCleanerRef &&_cleaner, - AsyncCleanerRef &&_cold_cleaner) { + AsyncCleanerRef &&_cold_cleaner, + rewrite_gen_t hot_tier_generations) { trimmer = std::move(_trimmer); trimmer->set_background_callback(this); main_cleaner = std::move(_cleaner); @@ -709,7 +720,8 @@ private: crimson::common::get_conf( "seastore_multiple_tiers_default_evict_ratio"), crimson::common::get_conf( - "seastore_multiple_tiers_fast_evict_ratio")); + "seastore_multiple_tiers_fast_evict_ratio"), + hot_tier_generations); } } @@ -958,10 +970,12 @@ private: double stop_evict_ratio; double default_evict_ratio; double fast_evict_ratio; + rewrite_gen_t hot_tier_generations; void init(double stop_ratio, double default_ratio, - double fast_ratio) { + double fast_ratio, + rewrite_gen_t hot_tier_generations) { ceph_assert(0 <= stop_ratio); ceph_assert(stop_ratio < default_ratio); ceph_assert(default_ratio < fast_ratio); @@ -970,6 +984,7 @@ private: stop_evict_ratio = stop_ratio; default_evict_ratio = default_ratio; fast_evict_ratio = fast_ratio; + this->hot_tier_generations = hot_tier_generations; } bool is_stop_mode() const { @@ -988,15 +1003,15 @@ private: rewrite_gen_t ret = gen; switch(eviction_mode) { case eviction_mode_t::STOP: - if (gen == MIN_COLD_GENERATION) { - ret = MIN_COLD_GENERATION - 1; + if (gen == hot_tier_generations) { + ret = hot_tier_generations - 1; } break; case eviction_mode_t::DEFAULT: break; case eviction_mode_t::FAST: - if (gen >= MIN_REWRITE_GENERATION && gen < MIN_COLD_GENERATION) { - ret = MIN_COLD_GENERATION; + if (gen >= MIN_REWRITE_GENERATION && gen < hot_tier_generations) { + ret = hot_tier_generations; } break; default: @@ -1094,13 +1109,17 @@ private: Device* primary_device = nullptr; std::size_t num_devices = 0; - rewrite_gen_t dynamic_max_rewrite_generation = REWRITE_GENERATIONS; + // without cold tier, the largest generation is less than hot_tier_generations + const rewrite_gen_t hot_tier_generations = NULL_GENERATION; + const rewrite_gen_t cold_tier_generations = NULL_GENERATION; + rewrite_gen_t dynamic_max_rewrite_generation = NULL_GENERATION; BackgroundProcess background_process; // TODO: drop once paddr->journal_seq_t is introduced SegmentSeqAllocatorRef ool_segment_seq_allocator; extent_len_t max_data_allocation_size = 0; friend class ::transaction_manager_test_t; + friend class Cache; }; using ExtentPlacementManagerRef = std::unique_ptr; diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc index 0be29b80a2b..4f1a593d841 100644 --- a/src/crimson/os/seastore/seastore_types.cc +++ b/src/crimson/os/seastore/seastore_types.cc @@ -287,8 +287,6 @@ std::ostream &operator<<(std::ostream &out, rewrite_gen_printer_t gen) return out << "GEN_INL"; } else if (gen.gen == OOL_GENERATION) { return out << "GEN_OOL"; - } else if (gen.gen > REWRITE_GENERATIONS) { - return out << "GEN_INVALID(" << (unsigned)gen.gen << ")!"; } else { return out << "GEN(" << (unsigned)gen.gen << ")"; } diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h index 5a80c6ef720..3d0d89ad391 100644 --- a/src/crimson/os/seastore/seastore_types.h +++ b/src/crimson/os/seastore/seastore_types.h @@ -1587,10 +1587,6 @@ constexpr rewrite_gen_t OOL_GENERATION = 2; // All the rewritten extents start with MIN_REWRITE_GENERATION constexpr rewrite_gen_t MIN_REWRITE_GENERATION = 3; -// without cold tier, the largest generation is less than MIN_COLD_GENERATION -constexpr rewrite_gen_t MIN_COLD_GENERATION = 5; -constexpr rewrite_gen_t MAX_REWRITE_GENERATION = 7; -constexpr rewrite_gen_t REWRITE_GENERATIONS = MAX_REWRITE_GENERATION + 1; constexpr rewrite_gen_t NULL_GENERATION = std::numeric_limits::max(); @@ -1606,16 +1602,20 @@ constexpr std::size_t generation_to_writer(rewrite_gen_t gen) { } // before EPM decision -constexpr bool is_target_rewrite_generation(rewrite_gen_t gen) { +constexpr bool is_target_rewrite_generation( + rewrite_gen_t gen, + rewrite_gen_t max_gen) { return gen == INIT_GENERATION || (gen >= MIN_REWRITE_GENERATION && - gen <= REWRITE_GENERATIONS); + gen <= max_gen + 1); } // after EPM decision -constexpr bool is_rewrite_generation(rewrite_gen_t gen) { +constexpr bool is_rewrite_generation( + rewrite_gen_t gen, + rewrite_gen_t max_gen) { return gen >= INLINE_GENERATION && - gen < REWRITE_GENERATIONS; + gen <= max_gen; } enum class data_category_t : uint8_t { diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index 8a7759a2225..53acf6c937a 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -802,7 +802,12 @@ TransactionManagerRef make_transaction_manager( shard_stats_t& shard_stats, bool is_test) { - auto epm = std::make_unique(); + rewrite_gen_t hot_tier_generations = crimson::common::get_conf( + "seastore_hot_tier_generations"); + rewrite_gen_t cold_tier_generations = crimson::common::get_conf( + "seastore_cold_tier_generations"); + auto epm = std::make_unique( + hot_tier_generations, cold_tier_generations); auto cache = std::make_unique(*epm); auto lba_manager = lba::create_lba_manager(*cache); auto sms = std::make_unique(); @@ -890,6 +895,7 @@ TransactionManagerRef make_transaction_manager( std::move(cold_sms), *backref_manager, epm->get_ool_segment_seq_allocator(), + hot_tier_generations + cold_tier_generations - 1, cleaner_is_detailed, /* is_cold = */ true); if (backend_type == backend_type_t::SEGMENTED) { @@ -906,6 +912,7 @@ TransactionManagerRef make_transaction_manager( std::move(sms), *backref_manager, epm->get_ool_segment_seq_allocator(), + hot_tier_generations - 1, cleaner_is_detailed); auto segment_cleaner = static_cast(cleaner.get()); for (auto id : segment_cleaner->get_device_ids()) { diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc index 2d867211edf..b70f24f79c9 100644 --- a/src/test/crimson/seastore/test_btree_lba_manager.cc +++ b/src/test/crimson/seastore/test_btree_lba_manager.cc @@ -139,7 +139,12 @@ struct btree_test_base : }).safe_then([this] { sms.reset(new SegmentManagerGroup()); journal = journal::make_segmented(*this, *this); - epm.reset(new ExtentPlacementManager()); + rewrite_gen_t hot_tier_generations = crimson::common::get_conf( + "seastore_hot_tier_generations"); + rewrite_gen_t cold_tier_generations = crimson::common::get_conf( + "seastore_cold_tier_generations"); + epm.reset(new ExtentPlacementManager( + hot_tier_generations, cold_tier_generations)); cache.reset(new Cache(*epm)); block_size = segment_manager->get_block_size(); diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc index 9eb4073b182..63a89bd1537 100644 --- a/src/test/crimson/seastore/test_seastore_cache.cc +++ b/src/test/crimson/seastore/test_seastore_cache.cc @@ -110,7 +110,12 @@ struct cache_test_t : public seastar_test_suite_t { return segment_manager->mkfs( segment_manager::get_ephemeral_device_config(0, 1, 0)); }).safe_then([this] { - epm.reset(new ExtentPlacementManager()); + rewrite_gen_t hot_tier_generations = crimson::common::get_conf( + "seastore_hot_tier_generations"); + rewrite_gen_t cold_tier_generations = crimson::common::get_conf( + "seastore_cold_tier_generations"); + epm.reset(new ExtentPlacementManager( + hot_tier_generations, cold_tier_generations)); cache.reset(new Cache(*epm)); current = paddr_t::make_seg_paddr(segment_id_t(segment_manager->get_device_id(), 0), 0); epm->test_init_no_background(segment_manager.get()); diff --git a/src/test/crimson/seastore/test_transaction_manager.cc b/src/test/crimson/seastore/test_transaction_manager.cc index 1b26e35466e..f03ef118cda 100644 --- a/src/test/crimson/seastore/test_transaction_manager.cc +++ b/src/test/crimson/seastore/test_transaction_manager.cc @@ -987,7 +987,7 @@ struct transaction_manager_test_t : epm->background_process .eviction_state - .init(stop_ratio, default_ratio, fast_ratio); + .init(stop_ratio, default_ratio, fast_ratio, epm->hot_tier_generations); // these variables are described in // EPM::BackgroundProcess::eviction_state_t::maybe_update_eviction_mode @@ -1040,7 +1040,7 @@ struct transaction_manager_test_t : assert(all_extent_types.size() == EXTENT_TYPES_MAX - 4); std::vector all_generations; - for (auto i = INIT_GENERATION; i < REWRITE_GENERATIONS; i++) { + for (auto i = INIT_GENERATION; i <= epm->dynamic_max_rewrite_generation; i++) { all_generations.push_back(i); } @@ -1063,7 +1063,7 @@ struct transaction_manager_test_t : expected_generations[t][INIT_GENERATION] = OOL_GENERATION; } - for (auto i = INIT_GENERATION + 1; i < REWRITE_GENERATIONS; i++) { + for (auto i = INIT_GENERATION + 1; i <= epm->dynamic_max_rewrite_generation; i++) { expected_generations[t][i] = i; } } @@ -1074,7 +1074,7 @@ struct transaction_manager_test_t : if (is_root_type(t) || is_lba_backref_node(t)) { continue; } - for (auto i = INIT_GENERATION + 1; i < REWRITE_GENERATIONS; i++) { + for (auto i = INIT_GENERATION + 1; i <= epm->dynamic_max_rewrite_generation; i++) { expected_generations[t][i] = func(i); } } @@ -1102,9 +1102,9 @@ struct transaction_manager_test_t : }; // verify that no data should go to the cold tier - update_data_gen_mapping([](rewrite_gen_t gen) -> rewrite_gen_t { - if (gen == MIN_COLD_GENERATION) { - return MIN_COLD_GENERATION - 1; + update_data_gen_mapping([this](rewrite_gen_t gen) -> rewrite_gen_t { + if (gen == epm->hot_tier_generations) { + return epm->hot_tier_generations - 1; } else { return gen; } @@ -1130,9 +1130,9 @@ struct transaction_manager_test_t : // verify that data must go to the cold tier run_until(ratio_D_size).get(); - update_data_gen_mapping([](rewrite_gen_t gen) { - if (gen >= MIN_REWRITE_GENERATION && gen < MIN_COLD_GENERATION) { - return MIN_COLD_GENERATION; + update_data_gen_mapping([this](rewrite_gen_t gen) { + if (gen >= MIN_REWRITE_GENERATION && gen < epm->hot_tier_generations) { + return epm->hot_tier_generations; } else { return gen; }