From: Yingxin Cheng Date: Wed, 31 Aug 2022 07:52:23 +0000 (+0800) Subject: crimson/os/seastore: introduce generic AsyncCleaner interface to EPM X-Git-Tag: v18.0.0~31^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=76c27932293b0f58622109eb698d16833796c7f5;p=ceph.git crimson/os/seastore: introduce generic AsyncCleaner interface to EPM Signed-off-by: Yingxin Cheng --- diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc index 5300f14e0e6f..576b2128bc34 100644 --- a/src/crimson/os/seastore/async_cleaner.cc +++ b/src/crimson/os/seastore/async_cleaner.cc @@ -642,7 +642,7 @@ std::ostream &operator<<( { os << "JournalTrimmer("; if (stats.trimmer.background_callback->is_ready()) { - os << "should_block_on_trim=" << stats.trimmer.should_block_on_trim() + os << "should_block_io_on_trim=" << stats.trimmer.should_block_io_on_trim() << ", should_(trim_dirty=" << stats.trimmer.should_trim_dirty() << ", trim_alloc=" << stats.trimmer.should_trim_alloc() << ")"; } else { @@ -788,7 +788,14 @@ void SpaceTrackerSimple::dump_usage(segment_id_t id) const id, live_bytes_by_segment[id].live_bytes); } -AsyncCleaner::AsyncCleaner( +std::ostream &operator<<( + std::ostream &os, const AsyncCleaner::stat_printer_t &stats) +{ + stats.cleaner.print(os, stats.detailed); + return os; +} + +SegmentCleaner::SegmentCleaner( config_t config, SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, @@ -803,7 +810,7 @@ AsyncCleaner::AsyncCleaner( config.validate(); } -void AsyncCleaner::register_metrics() +void SegmentCleaner::register_metrics() { namespace sm = seastar::metrics; stats.segment_util.buckets.resize(UTIL_BUCKETS); @@ -816,7 +823,7 @@ void AsyncCleaner::register_metrics() i = get_bucket_index(UTIL_STATE_EMPTY); stats.segment_util.buckets[i].count = segments.get_num_segments(); - metrics.add_group("async_cleaner", { + metrics.add_group("segment_cleaner", { sm::make_counter("segments_number", [this] { return segments.get_num_segments(); }, sm::description("the number of segments")), @@ -912,13 +919,13 @@ void AsyncCleaner::register_metrics() }); } -segment_id_t AsyncCleaner::allocate_segment( +segment_id_t SegmentCleaner::allocate_segment( segment_seq_t seq, segment_type_t type, data_category_t category, reclaim_gen_t generation) { - LOG_PREFIX(AsyncCleaner::allocate_segment); + LOG_PREFIX(SegmentCleaner::allocate_segment); assert(seq != NULL_SEG_SEQ); ceph_assert(type == segment_type_t::OOL || trimmer != nullptr); // segment_type_t::JOURNAL @@ -944,9 +951,9 @@ segment_id_t AsyncCleaner::allocate_segment( return NULL_SEG_ID; } -void AsyncCleaner::close_segment(segment_id_t segment) +void SegmentCleaner::close_segment(segment_id_t segment) { - LOG_PREFIX(AsyncCleaner::close_segment); + LOG_PREFIX(SegmentCleaner::close_segment); auto old_usage = calc_utilization(segment); segments.mark_closed(segment); auto &seg_info = segments[segment]; @@ -962,7 +969,7 @@ void AsyncCleaner::close_segment(segment_id_t segment) INFO("closed, {} -- {}", stat_printer_t{*this, false}, seg_info); } -double AsyncCleaner::calc_gc_benefit_cost( +double SegmentCleaner::calc_gc_benefit_cost( segment_id_t id, const sea_time_point &now_time, const sea_time_point &bound_time) const @@ -1004,8 +1011,8 @@ double AsyncCleaner::calc_gc_benefit_cost( (2 * age_factor - 2) * util + 1); } -AsyncCleaner::do_reclaim_space_ret -AsyncCleaner::do_reclaim_space( +SegmentCleaner::do_reclaim_space_ret +SegmentCleaner::do_reclaim_space( const std::vector &backref_extents, const backref_pin_list_t &pin_list, std::size_t &reclaimed, @@ -1017,14 +1024,14 @@ AsyncCleaner::do_reclaim_space( runs++; return extent_callback->with_transaction_intr( Transaction::src_t::CLEANER_RECLAIM, - "reclaim_space", + "clean_reclaim_space", [this, &backref_extents, &pin_list, &reclaimed](auto &t) { return seastar::do_with( std::vector(backref_extents), [this, &t, &reclaimed, &pin_list](auto &extents) { - LOG_PREFIX(AsyncCleaner::do_reclaim_space); + LOG_PREFIX(SegmentCleaner::do_reclaim_space); // calculate live extents auto cached_backref_entries = backref_manager.get_cached_backref_entries_in_range( @@ -1057,7 +1064,7 @@ AsyncCleaner::do_reclaim_space( backref_entries, [this, &extents, &t](auto &ent) { - LOG_PREFIX(AsyncCleaner::do_reclaim_space); + LOG_PREFIX(SegmentCleaner::do_reclaim_space); TRACET("getting extent of type {} at {}~{}", t, ent.type, @@ -1095,9 +1102,9 @@ AsyncCleaner::do_reclaim_space( }); } -AsyncCleaner::reclaim_space_ret AsyncCleaner::reclaim_space() +SegmentCleaner::clean_space_ret SegmentCleaner::clean_space() { - LOG_PREFIX(AsyncCleaner::reclaim_space); + LOG_PREFIX(SegmentCleaner::clean_space); assert(background_callback->is_ready()); if (!reclaim_state) { segment_id_t seg_id = get_next_reclaim_segment(); @@ -1178,9 +1185,9 @@ AsyncCleaner::reclaim_space_ret AsyncCleaner::reclaim_space() reclaim_state.reset(); return sm_group->release_segment(segment_to_release ).handle_error( - reclaim_space_ertr::pass_further{}, + clean_space_ertr::pass_further{}, crimson::ct_error::assert_all{ - "AsyncCleaner::reclaim_space encountered invalid error in release_segment" + "SegmentCleaner::clean_space encountered invalid error in release_segment" } ).safe_then([this, FNAME, segment_to_release] { auto old_usage = calc_utilization(segment_to_release); @@ -1198,16 +1205,16 @@ AsyncCleaner::reclaim_space_ret AsyncCleaner::reclaim_space() background_callback->maybe_wake_blocked_io(); }); } else { - return reclaim_space_ertr::now(); + return clean_space_ertr::now(); } }); }); }); } -AsyncCleaner::mount_ret AsyncCleaner::mount() +SegmentCleaner::mount_ret SegmentCleaner::mount() { - LOG_PREFIX(AsyncCleaner::mount); + LOG_PREFIX(SegmentCleaner::mount); const auto& sms = sm_group->get_segment_managers(); INFO("{} segment managers", sms.size()); @@ -1293,11 +1300,11 @@ AsyncCleaner::mount_ret AsyncCleaner::mount() }); } -AsyncCleaner::scan_extents_ret AsyncCleaner::scan_no_tail_segment( +SegmentCleaner::scan_extents_ret SegmentCleaner::scan_no_tail_segment( const segment_header_t &segment_header, segment_id_t segment_id) { - LOG_PREFIX(AsyncCleaner::scan_no_tail_segment); + LOG_PREFIX(SegmentCleaner::scan_no_tail_segment); INFO("scan {} {}", segment_id, segment_header); return seastar::do_with( scan_valid_records_cursor({ @@ -1352,7 +1359,7 @@ AsyncCleaner::scan_extents_ret AsyncCleaner::scan_no_tail_segment( }); } -bool AsyncCleaner::check_usage() +bool SegmentCleaner::check_usage() { SpaceTrackerIRef tracker(space_tracker->make_empty()); extent_callback->with_transaction_weak( @@ -1390,11 +1397,11 @@ bool AsyncCleaner::check_usage() return space_tracker->equals(*tracker); } -void AsyncCleaner::mark_space_used( +void SegmentCleaner::mark_space_used( paddr_t addr, extent_len_t len) { - LOG_PREFIX(AsyncCleaner::mark_space_used); + LOG_PREFIX(SegmentCleaner::mark_space_used); assert(background_callback->get_state() >= state_t::SCAN_SPACE); // TODO: drop if (addr.get_addr_type() != paddr_types_t::SEGMENT) { @@ -1420,11 +1427,11 @@ void AsyncCleaner::mark_space_used( space_tracker->get_usage(seg_addr.get_segment_id())); } -void AsyncCleaner::mark_space_free( +void SegmentCleaner::mark_space_free( paddr_t addr, extent_len_t len) { - LOG_PREFIX(AsyncCleaner::mark_space_free); + LOG_PREFIX(SegmentCleaner::mark_space_free); assert(background_callback->get_state() >= state_t::SCAN_SPACE); // TODO: drop if (addr.get_addr_type() != paddr_types_t::SEGMENT) { @@ -1453,9 +1460,9 @@ void AsyncCleaner::mark_space_free( space_tracker->get_usage(seg_addr.get_segment_id())); } -segment_id_t AsyncCleaner::get_next_reclaim_segment() const +segment_id_t SegmentCleaner::get_next_reclaim_segment() const { - LOG_PREFIX(AsyncCleaner::get_next_reclaim_segment); + LOG_PREFIX(SegmentCleaner::get_next_reclaim_segment); segment_id_t id = NULL_SEG_ID; double max_benefit_cost = 0; sea_time_point now_time; @@ -1490,13 +1497,13 @@ segment_id_t AsyncCleaner::get_next_reclaim_segment() const return id; } else { ceph_assert(get_segments_reclaimable() == 0); - // see should_reclaim_space() + // see should_clean_space() ceph_abort("impossible!"); return NULL_SEG_ID; } } -void AsyncCleaner::reserve_projected_usage(std::size_t projected_usage) +void SegmentCleaner::reserve_projected_usage(std::size_t projected_usage) { assert(background_callback->is_ready()); stats.projected_used_bytes += projected_usage; @@ -1504,7 +1511,7 @@ void AsyncCleaner::reserve_projected_usage(std::size_t projected_usage) stats.projected_used_bytes_sum += stats.projected_used_bytes; } -void AsyncCleaner::release_projected_usage(std::size_t projected_usage) +void SegmentCleaner::release_projected_usage(std::size_t projected_usage) { assert(background_callback->is_ready()); ceph_assert(stats.projected_used_bytes >= projected_usage); @@ -1512,29 +1519,27 @@ void AsyncCleaner::release_projected_usage(std::size_t projected_usage) background_callback->maybe_wake_blocked_io(); } -std::ostream &operator<<( - std::ostream &os, const AsyncCleaner::stat_printer_t &stats) +void SegmentCleaner::print(std::ostream &os, bool is_detailed) const { - os << "AsyncCleaner("; - if (stats.cleaner.background_callback->is_ready()) { - os << "should_block_on_reclaim=" << stats.cleaner.should_block_on_reclaim() - << ", should_reclaim=" << stats.cleaner.should_reclaim_space(); + os << "SegmentCleaner("; + if (background_callback->is_ready()) { + os << "should_block_io_on_clean=" << should_block_io_on_clean() + << ", should_clean=" << should_clean_space(); } else { os << "not-ready"; } - os << ", projected_avail_ratio=" << stats.cleaner.get_projected_available_ratio() - << ", reclaim_ratio=" << stats.cleaner.get_reclaim_ratio() - << ", alive_ratio=" << stats.cleaner.get_alive_ratio(); - if (stats.detailed) { + os << ", projected_avail_ratio=" << get_projected_available_ratio() + << ", reclaim_ratio=" << get_reclaim_ratio() + << ", alive_ratio=" << get_alive_ratio(); + if (is_detailed) { os << ", unavailable_unreclaimable=" - << stats.cleaner.get_unavailable_unreclaimable_bytes() << "B" + << get_unavailable_unreclaimable_bytes() << "B" << ", unavailable_reclaimble=" - << stats.cleaner.get_unavailable_reclaimable_bytes() << "B" - << ", alive=" << stats.cleaner.stats.used_bytes << "B" - << ", " << stats.cleaner.segments; + << get_unavailable_reclaimable_bytes() << "B" + << ", alive=" << stats.used_bytes << "B" + << ", " << segments; } os << ")"; - return os; } } diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h index 3ca7a69acdae..033be6a853fb 100644 --- a/src/crimson/os/seastore/async_cleaner.h +++ b/src/crimson/os/seastore/async_cleaner.h @@ -535,7 +535,7 @@ public: return get_alloc_tail_target() > journal_alloc_tail; } - bool should_block_on_trim() const { + bool should_block_io_on_trim() const { return get_tail_limit() > get_journal_tail(); } @@ -819,12 +819,69 @@ public: bool equals(const SpaceTrackerI &other) const; }; -class AsyncCleaner : public SegmentProvider { +/* + * AsyncCleaner + * + * Interface for ExtentPlacementManager::BackgroundProcess + * to do background cleaning. + */ +class AsyncCleaner { public: using state_t = BackgroundListener::state_t; using base_ertr = crimson::errorator< crimson::ct_error::input_output_error>; + virtual void set_background_callback(BackgroundListener *) = 0; + + virtual void set_extent_callback(ExtentCallbackInterface *) = 0; + + virtual store_statfs_t get_stat() const = 0; + + virtual void print(std::ostream &, bool is_detailed) const = 0; + + virtual bool check_usage_is_empty() const = 0; + + using mount_ertr = base_ertr; + using mount_ret = mount_ertr::future<>; + virtual mount_ret mount() = 0; + + virtual void mark_space_used(paddr_t, extent_len_t) = 0; + + virtual void mark_space_free(paddr_t, extent_len_t) = 0; + + virtual void reserve_projected_usage(std::size_t) = 0; + + virtual void release_projected_usage(std::size_t) = 0; + + virtual bool should_block_io_on_clean() const = 0; + + virtual bool should_clean_space() const = 0; + + using clean_space_ertr = base_ertr; + using clean_space_ret = clean_space_ertr::future<>; + virtual clean_space_ret clean_space() = 0; + + // test only + virtual bool check_usage() = 0; + + struct stat_printer_t { + const AsyncCleaner &cleaner; + bool detailed = false; + }; + + virtual ~AsyncCleaner() {} +}; + +using AsyncCleanerRef = std::unique_ptr; + +std::ostream &operator<<( + std::ostream &, const AsyncCleaner::stat_printer_t &); + +class SegmentCleaner; +using SegmentCleanerRef = std::unique_ptr; + +class SegmentCleaner : public SegmentProvider, public AsyncCleaner { +public: /// Config struct config_t { /// Ratio of maximum available space to disable reclaiming. @@ -860,59 +917,7 @@ public: } }; -private: - const bool detailed; - const config_t config; - - SegmentManagerGroupRef sm_group; - BackrefManager &backref_manager; - - SpaceTrackerIRef space_tracker; - segments_info_t segments; - - struct { - /** - * used_bytes - * - * Bytes occupied by live extents - */ - uint64_t used_bytes = 0; - - /** - * projected_used_bytes - * - * Sum of projected bytes used by each transaction between throttle - * acquisition and commit completion. See reserve_projected_usage() - */ - uint64_t projected_used_bytes = 0; - uint64_t projected_count = 0; - uint64_t projected_used_bytes_sum = 0; - - uint64_t closed_journal_used_bytes = 0; - uint64_t closed_journal_total_bytes = 0; - uint64_t closed_ool_used_bytes = 0; - uint64_t closed_ool_total_bytes = 0; - - uint64_t reclaiming_bytes = 0; - uint64_t reclaimed_bytes = 0; - uint64_t reclaimed_segment_bytes = 0; - - seastar::metrics::histogram segment_util; - } stats; - seastar::metrics::metric_group metrics; - void register_metrics(); - - // optional, set if this cleaner is assigned to SegmentedJournal - JournalTrimmer *trimmer = nullptr; - - ExtentCallbackInterface *extent_callback = nullptr; - - BackgroundListener *background_callback = nullptr; - - SegmentSeqAllocatorRef ool_segment_seq_allocator; - -public: - AsyncCleaner( + SegmentCleaner( config_t config, SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, @@ -922,24 +927,17 @@ public: return *ool_segment_seq_allocator; } - void set_extent_callback(ExtentCallbackInterface *cb) { - extent_callback = cb; - } - - void set_background_callback(BackgroundListener *cb) { - background_callback = cb; - } - void set_journal_trimmer(JournalTrimmer &_trimmer) { trimmer = &_trimmer; } - using mount_ertr = base_ertr; - using mount_ret = mount_ertr::future<>; - mount_ret mount(); - - bool check_usage_is_empty() { - return space_tracker->equals(*space_tracker->make_empty()); + static SegmentCleanerRef create( + config_t config, + SegmentManagerGroupRef&& sm_group, + BackrefManager &backref_manager, + bool detailed) { + return std::make_unique( + config, std::move(sm_group), backref_manager, detailed); } /* @@ -972,19 +970,19 @@ public: return sm_group.get(); } - void mark_space_used( - paddr_t addr, - extent_len_t len); - - void mark_space_free( - paddr_t addr, - extent_len_t len); + /* + * AsyncCleaner interfaces + */ - void reserve_projected_usage(std::size_t projected_usage); + void set_background_callback(BackgroundListener *cb) final { + background_callback = cb; + } - void release_projected_usage(size_t projected_usage); + void set_extent_callback(ExtentCallbackInterface *cb) final { + extent_callback = cb; + } - store_statfs_t get_stat() const { + store_statfs_t get_stat() const final { store_statfs_t st; st.total = segments.get_total_bytes(); st.available = segments.get_total_bytes() - stats.used_bytes; @@ -996,7 +994,23 @@ public: return st; } - bool should_block_on_reclaim() const { + void print(std::ostream &, bool is_detailed) const final; + + bool check_usage_is_empty() const final { + return space_tracker->equals(*space_tracker->make_empty()); + } + + mount_ret mount() final; + + void mark_space_used(paddr_t, extent_len_t) final; + + void mark_space_free(paddr_t, extent_len_t) final; + + void reserve_projected_usage(std::size_t) final; + + void release_projected_usage(size_t) final; + + bool should_block_io_on_clean() const final { assert(background_callback->is_ready()); if (get_segments_reclaimable() == 0) { return false; @@ -1005,7 +1019,7 @@ public: return aratio < config.available_ratio_hard_limit; } - bool should_reclaim_space() const { + bool should_clean_space() const final { assert(background_callback->is_ready()); if (get_segments_reclaimable() == 0) { return false; @@ -1019,19 +1033,11 @@ public: ); } - using reclaim_space_ertr = base_ertr; - using reclaim_space_ret = reclaim_space_ertr::future<>; - reclaim_space_ret reclaim_space(); - - struct stat_printer_t { - const AsyncCleaner &cleaner; - bool detailed = false; - }; - friend std::ostream &operator<<(std::ostream &, const stat_printer_t &); + clean_space_ret clean_space() final; // Testing interfaces - bool check_usage(); + bool check_usage() final; private: /* @@ -1215,10 +1221,57 @@ private: ool_segment_seq_allocator->set_next_segment_seq(seq); } } -}; -using AsyncCleanerRef = std::unique_ptr; -std::ostream &operator<<( - std::ostream &, const AsyncCleaner::stat_printer_t &); + const bool detailed; + const config_t config; + + SegmentManagerGroupRef sm_group; + BackrefManager &backref_manager; + + SpaceTrackerIRef space_tracker; + segments_info_t segments; + + struct { + /** + * used_bytes + * + * Bytes occupied by live extents + */ + uint64_t used_bytes = 0; + + /** + * projected_used_bytes + * + * Sum of projected bytes used by each transaction between throttle + * acquisition and commit completion. See reserve_projected_usage() + */ + uint64_t projected_used_bytes = 0; + uint64_t projected_count = 0; + uint64_t projected_used_bytes_sum = 0; + + uint64_t closed_journal_used_bytes = 0; + uint64_t closed_journal_total_bytes = 0; + uint64_t closed_ool_used_bytes = 0; + uint64_t closed_ool_total_bytes = 0; + + uint64_t reclaiming_bytes = 0; + uint64_t reclaimed_bytes = 0; + uint64_t reclaimed_segment_bytes = 0; + + seastar::metrics::histogram segment_util; + } stats; + seastar::metrics::metric_group metrics; + void register_metrics(); + + // optional, set if this cleaner is assigned to SegmentedJournal + JournalTrimmer *trimmer = nullptr; + + ExtentCallbackInterface *extent_callback = nullptr; + + BackgroundListener *background_callback = nullptr; + + // TODO: drop once paddr->journal_seq_t is introduced + SegmentSeqAllocatorRef ool_segment_seq_allocator; +}; } diff --git a/src/crimson/os/seastore/extent_placement_manager.cc b/src/crimson/os/seastore/extent_placement_manager.cc index 383acaf3386b..e9cba6eead26 100644 --- a/src/crimson/os/seastore/extent_placement_manager.cc +++ b/src/crimson/os/seastore/extent_placement_manager.cc @@ -180,24 +180,26 @@ void ExtentPlacementManager::init( writer_refs.clear(); ceph_assert(RECLAIM_GENERATIONS > 0); + auto segment_cleaner = dynamic_cast(cleaner.get()); + ceph_assert(segment_cleaner != nullptr); data_writers_by_gen.resize(RECLAIM_GENERATIONS, {}); for (reclaim_gen_t gen = 0; gen < RECLAIM_GENERATIONS; ++gen) { writer_refs.emplace_back(std::make_unique( - data_category_t::DATA, gen, *cleaner, - cleaner->get_ool_segment_seq_allocator())); + data_category_t::DATA, gen, *segment_cleaner, + segment_cleaner->get_ool_segment_seq_allocator())); data_writers_by_gen[gen] = writer_refs.back().get(); } md_writers_by_gen.resize(RECLAIM_GENERATIONS - 1, {}); for (reclaim_gen_t gen = 1; gen < RECLAIM_GENERATIONS; ++gen) { writer_refs.emplace_back(std::make_unique( - data_category_t::METADATA, gen, *cleaner, - cleaner->get_ool_segment_seq_allocator())); + data_category_t::METADATA, gen, *segment_cleaner, + segment_cleaner->get_ool_segment_seq_allocator())); md_writers_by_gen[gen - 1] = writer_refs.back().get(); } - for (auto *device : cleaner->get_segment_manager_group() - ->get_segment_managers()) { + for (auto *device : segment_cleaner->get_segment_manager_group() + ->get_segment_managers()) { add_device(device); } @@ -361,13 +363,13 @@ ExtentPlacementManager::BackgroundProcess::reserve_projected_usage( // prepare until the prior one exits and clears this. ++stats.io_count; bool is_blocked = false; - if (trimmer->should_block_on_trim()) { + if (trimmer->should_block_io_on_trim()) { is_blocked = true; ++stats.io_blocked_count_trim; } - if (cleaner->should_block_on_reclaim()) { + if (cleaner->should_block_io_on_clean()) { is_blocked = true; - ++stats.io_blocked_count_reclaim; + ++stats.io_blocked_count_clean; } if (is_blocked) { ++stats.io_blocking_num; @@ -437,11 +439,11 @@ ExtentPlacementManager::BackgroundProcess::do_background_cycle() "do_background_cycle encountered invalid error in trim_dirty" } ); - } else if (cleaner->should_reclaim_space()) { - return cleaner->reclaim_space( + } else if (cleaner->should_clean_space()) { + return cleaner->clean_space( ).handle_error( crimson::ct_error::assert_all{ - "do_background_cycle encountered invalid error in reclaim_space" + "do_background_cycle encountered invalid error in clean_space" } ); } else { @@ -459,8 +461,8 @@ void ExtentPlacementManager::BackgroundProcess::register_metrics() sm::description("IOs that are blocked by gc")), sm::make_counter("io_blocked_count_trim", stats.io_blocked_count_trim, sm::description("IOs that are blocked by trimming")), - sm::make_counter("io_blocked_count_reclaim", stats.io_blocked_count_reclaim, - sm::description("IOs that are blocked by reclaimming")), + sm::make_counter("io_blocked_count_clean", stats.io_blocked_count_clean, + sm::description("IOs that are blocked by cleaning")), sm::make_counter("io_blocked_sum", stats.io_blocked_sum, sm::description("the sum of blocking IOs")) }); diff --git a/src/crimson/os/seastore/extent_placement_manager.h b/src/crimson/os/seastore/extent_placement_manager.h index 985b52580ecd..98cfc76f7ebb 100644 --- a/src/crimson/os/seastore/extent_placement_manager.h +++ b/src/crimson/os/seastore/extent_placement_manager.h @@ -403,15 +403,15 @@ private: bool background_should_run() const { assert(is_ready()); - return cleaner->should_reclaim_space() + return cleaner->should_clean_space() || trimmer->should_trim_dirty() || trimmer->should_trim_alloc(); } bool should_block_io() const { assert(is_ready()); - return trimmer->should_block_on_trim() || - cleaner->should_block_on_reclaim(); + return trimmer->should_block_io_on_trim() || + cleaner->should_block_io_on_clean(); } seastar::future<> do_background_cycle(); @@ -423,7 +423,7 @@ private: uint64_t io_count = 0; uint64_t io_blocked_count = 0; uint64_t io_blocked_count_trim = 0; - uint64_t io_blocked_count_reclaim = 0; + uint64_t io_blocked_count_clean = 0; uint64_t io_blocked_sum = 0; } stats; seastar::metrics::metric_group metrics; diff --git a/src/crimson/os/seastore/segment_seq_allocator.h b/src/crimson/os/seastore/segment_seq_allocator.h index c659a9f6e3dc..28c81bf324b9 100644 --- a/src/crimson/os/seastore/segment_seq_allocator.h +++ b/src/crimson/os/seastore/segment_seq_allocator.h @@ -41,7 +41,7 @@ private: segment_seq_t next_segment_seq = 0; segment_type_t type = segment_type_t::NULL_SEG; friend class journal::SegmentedJournal; - friend class AsyncCleaner; + friend class SegmentCleaner; }; using SegmentSeqAllocatorRef = diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index ef7645fbe29d..dfa0588f86a3 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -661,16 +661,16 @@ TransactionManagerRef make_transaction_manager( ceph_assert(roll_start % primary_device->get_block_size() == 0); bool cleaner_is_detailed; - AsyncCleaner::config_t cleaner_config; + SegmentCleaner::config_t cleaner_config; JournalTrimmerImpl::config_t trimmer_config; if (is_test) { cleaner_is_detailed = true; - cleaner_config = AsyncCleaner::config_t::get_test(); + cleaner_config = SegmentCleaner::config_t::get_test(); trimmer_config = JournalTrimmerImpl::config_t::get_test( roll_size, journal_type); } else { cleaner_is_detailed = false; - cleaner_config = AsyncCleaner::config_t::get_default(); + cleaner_config = SegmentCleaner::config_t::get_default(); trimmer_config = JournalTrimmerImpl::config_t::get_default( roll_size, journal_type); } @@ -679,21 +679,21 @@ TransactionManagerRef make_transaction_manager( *backref_manager, trimmer_config, journal_type, roll_start, roll_size); - auto async_cleaner = std::make_unique( + auto segment_cleaner = SegmentCleaner::create( cleaner_config, std::move(sms), *backref_manager, cleaner_is_detailed); if (journal_type == journal_type_t::SEGMENTED) { - cache->set_segment_provider(*async_cleaner); - async_cleaner->set_journal_trimmer(*journal_trimmer); + cache->set_segment_provider(*segment_cleaner); + segment_cleaner->set_journal_trimmer(*journal_trimmer); } JournalRef journal; if (journal_type == journal_type_t::SEGMENTED) { journal = journal::make_segmented( - *async_cleaner, + *segment_cleaner, *journal_trimmer); } else { journal = journal::make_circularbounded( @@ -702,7 +702,7 @@ TransactionManagerRef make_transaction_manager( ""); } - epm->init(std::move(journal_trimmer), std::move(async_cleaner)); + epm->init(std::move(journal_trimmer), std::move(segment_cleaner)); epm->set_primary_device(primary_device); return std::make_unique(