From f46161bbbc8a576d43f528417c906955e7ca27ef Mon Sep 17 00:00:00 2001 From: myoungwon oh Date: Wed, 1 Jun 2022 21:55:27 +0900 Subject: [PATCH] seastore: rename segment cleaner to async cleaner Signed-off-by: Myoungwon Oh --- src/crimson/os/seastore/CMakeLists.txt | 2 +- .../{segment_cleaner.cc => async_cleaner.cc} | 102 +++++++++--------- .../{segment_cleaner.h => async_cleaner.h} | 12 +-- src/crimson/os/seastore/cache.cc | 4 +- src/crimson/os/seastore/cache.h | 4 +- .../os/seastore/journal/segment_allocator.cc | 2 +- .../os/seastore/journal/segmented_journal.h | 2 +- src/crimson/os/seastore/seastore.cc | 2 +- .../os/seastore/segment_seq_allocator.h | 4 +- .../os/seastore/transaction_manager.cc | 60 +++++------ src/crimson/os/seastore/transaction_manager.h | 24 ++--- .../onode_tree/test_fltree_onode_manager.cc | 2 +- .../seastore/onode_tree/test_staged_fltree.cc | 14 +-- .../crimson/seastore/test_seastore_journal.cc | 2 +- .../seastore/test_transaction_manager.cc | 10 +- .../seastore/transaction_manager_test_state.h | 14 +-- 16 files changed, 130 insertions(+), 130 deletions(-) rename src/crimson/os/seastore/{segment_cleaner.cc => async_cleaner.cc} (94%) rename src/crimson/os/seastore/{segment_cleaner.h => async_cleaner.h} (99%) diff --git a/src/crimson/os/seastore/CMakeLists.txt b/src/crimson/os/seastore/CMakeLists.txt index 55d2168cebb1..ee3aa47cc533 100644 --- a/src/crimson/os/seastore/CMakeLists.txt +++ b/src/crimson/os/seastore/CMakeLists.txt @@ -8,7 +8,7 @@ set(crimson_seastore_srcs transaction.cc cache.cc lba_manager.cc - segment_cleaner.cc + async_cleaner.cc backref_manager.cc backref/backref_tree_node.cc backref/btree_backref_manager.cc diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc similarity index 94% rename from src/crimson/os/seastore/segment_cleaner.cc rename to src/crimson/os/seastore/async_cleaner.cc index a3c3d6bb04bd..2e069a81a307 100644 --- a/src/crimson/os/seastore/segment_cleaner.cc +++ b/src/crimson/os/seastore/async_cleaner.cc @@ -5,7 +5,7 @@ #include "crimson/os/seastore/logging.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/transaction_manager.h" SET_SUBSYS(seastore_cleaner); @@ -386,7 +386,7 @@ void SpaceTrackerSimple::dump_usage(segment_id_t id) const id, live_bytes_by_segment[id].live_bytes); } -SegmentCleaner::SegmentCleaner( +AsyncCleaner::AsyncCleaner( config_t config, SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, @@ -402,7 +402,7 @@ SegmentCleaner::SegmentCleaner( config.validate(); } -void SegmentCleaner::register_metrics() +void AsyncCleaner::register_metrics() { namespace sm = seastar::metrics; stats.segment_util.buckets.resize(UTIL_BUCKETS); @@ -415,7 +415,7 @@ void SegmentCleaner::register_metrics() i = get_bucket_index(UTIL_STATE_EMPTY); stats.segment_util.buckets[i].count = segments.get_num_segments(); - metrics.add_group("segment_cleaner", { + metrics.add_group("async_cleaner", { sm::make_counter("segments_number", [this] { return segments.get_num_segments(); }, sm::description("the number of segments")), @@ -529,11 +529,11 @@ void SegmentCleaner::register_metrics() }); } -segment_id_t SegmentCleaner::allocate_segment( +segment_id_t AsyncCleaner::allocate_segment( segment_seq_t seq, segment_type_t type) { - LOG_PREFIX(SegmentCleaner::allocate_segment); + LOG_PREFIX(AsyncCleaner::allocate_segment); assert(seq != NULL_SEG_SEQ); for (auto it = segments.begin(); it != segments.end(); @@ -558,11 +558,11 @@ segment_id_t SegmentCleaner::allocate_segment( return NULL_SEG_ID; } -void SegmentCleaner::update_journal_tail_target( +void AsyncCleaner::update_journal_tail_target( journal_seq_t dirty_replay_from, journal_seq_t alloc_replay_from) { - LOG_PREFIX(SegmentCleaner::update_journal_tail_target); + LOG_PREFIX(AsyncCleaner::update_journal_tail_target); if (disable_trim) return; assert(dirty_replay_from.offset.get_addr_type() != addr_types_t::RANDOM_BLOCK); assert(alloc_replay_from.offset.get_addr_type() != addr_types_t::RANDOM_BLOCK); @@ -594,10 +594,10 @@ void SegmentCleaner::update_journal_tail_target( maybe_wake_gc_blocked_io(); } -void SegmentCleaner::update_alloc_info_replay_from( +void AsyncCleaner::update_alloc_info_replay_from( journal_seq_t alloc_replay_from) { - LOG_PREFIX(SegmentCleaner::update_alloc_info_replay_from); + LOG_PREFIX(AsyncCleaner::update_alloc_info_replay_from); if (alloc_info_replay_from == JOURNAL_SEQ_NULL || alloc_replay_from > alloc_info_replay_from) { DEBUG("alloc_info_replay_from={} => {}", @@ -606,9 +606,9 @@ void SegmentCleaner::update_alloc_info_replay_from( } } -void SegmentCleaner::update_journal_tail_committed(journal_seq_t committed) +void AsyncCleaner::update_journal_tail_committed(journal_seq_t committed) { - LOG_PREFIX(SegmentCleaner::update_journal_tail_committed); + LOG_PREFIX(AsyncCleaner::update_journal_tail_committed); assert(committed.offset.get_addr_type() != addr_types_t::RANDOM_BLOCK); if (committed == JOURNAL_SEQ_NULL) { return; @@ -631,9 +631,9 @@ void SegmentCleaner::update_journal_tail_committed(journal_seq_t committed) } } -void SegmentCleaner::close_segment(segment_id_t segment) +void AsyncCleaner::close_segment(segment_id_t segment) { - LOG_PREFIX(SegmentCleaner::close_segment); + LOG_PREFIX(AsyncCleaner::close_segment); auto old_usage = calc_utilization(segment); segments.mark_closed(segment); auto &seg_info = segments[segment]; @@ -653,7 +653,7 @@ void SegmentCleaner::close_segment(segment_id_t segment) get_reclaim_ratio()); } -SegmentCleaner::trim_backrefs_ret SegmentCleaner::trim_backrefs( +AsyncCleaner::trim_backrefs_ret AsyncCleaner::trim_backrefs( Transaction &t, journal_seq_t limit) { @@ -664,7 +664,7 @@ SegmentCleaner::trim_backrefs_ret SegmentCleaner::trim_backrefs( ); } -SegmentCleaner::rewrite_dirty_ret SegmentCleaner::rewrite_dirty( +AsyncCleaner::rewrite_dirty_ret AsyncCleaner::rewrite_dirty( Transaction &t, journal_seq_t limit) { @@ -673,7 +673,7 @@ SegmentCleaner::rewrite_dirty_ret SegmentCleaner::rewrite_dirty( limit, config.rewrite_dirty_bytes_per_cycle ).si_then([=, &t](auto dirty_list) { - LOG_PREFIX(SegmentCleaner::rewrite_dirty); + LOG_PREFIX(AsyncCleaner::rewrite_dirty); DEBUGT("rewrite {} dirty extents", t, dirty_list.size()); return seastar::do_with( std::move(dirty_list), @@ -688,7 +688,7 @@ SegmentCleaner::rewrite_dirty_ret SegmentCleaner::rewrite_dirty( }); } -SegmentCleaner::gc_cycle_ret SegmentCleaner::GCProcess::run() +AsyncCleaner::gc_cycle_ret AsyncCleaner::GCProcess::run() { return seastar::do_until( [this] { return is_stopping(); }, @@ -706,7 +706,7 @@ SegmentCleaner::gc_cycle_ret SegmentCleaner::GCProcess::run() }); } -SegmentCleaner::gc_cycle_ret SegmentCleaner::do_gc_cycle() +AsyncCleaner::gc_cycle_ret AsyncCleaner::do_gc_cycle() { if (gc_should_trim_journal()) { return gc_trim_journal( @@ -736,8 +736,8 @@ SegmentCleaner::gc_cycle_ret SegmentCleaner::do_gc_cycle() } } -SegmentCleaner::gc_trim_backref_ret -SegmentCleaner::gc_trim_backref(journal_seq_t limit) { +AsyncCleaner::gc_trim_backref_ret +AsyncCleaner::gc_trim_backref(journal_seq_t limit) { return seastar::do_with( journal_seq_t(), [this, limit=std::move(limit)](auto &seq) mutable { @@ -772,7 +772,7 @@ SegmentCleaner::gc_trim_backref(journal_seq_t limit) { }); } -SegmentCleaner::gc_trim_journal_ret SegmentCleaner::gc_trim_journal() +AsyncCleaner::gc_trim_journal_ret AsyncCleaner::gc_trim_journal() { return gc_trim_backref(get_dirty_tail() ).safe_then([this](auto seq) { @@ -791,8 +791,8 @@ SegmentCleaner::gc_trim_journal_ret SegmentCleaner::gc_trim_journal() }); } -SegmentCleaner::retrieve_live_extents_ret -SegmentCleaner::_retrieve_live_extents( +AsyncCleaner::retrieve_live_extents_ret +AsyncCleaner::_retrieve_live_extents( Transaction &t, std::set< backref_buf_entry_t, @@ -806,7 +806,7 @@ SegmentCleaner::_retrieve_live_extents( return trans_intr::parallel_for_each( backrefs, [this, &extents, &t, &seq](auto &ent) { - LOG_PREFIX(SegmentCleaner::_retrieve_live_extents); + LOG_PREFIX(AsyncCleaner::_retrieve_live_extents); DEBUGT("getting extent of type {} at {}~{}", t, ent.type, @@ -833,8 +833,8 @@ SegmentCleaner::_retrieve_live_extents( }); } -SegmentCleaner::retrieve_backref_mappings_ret -SegmentCleaner::retrieve_backref_mappings( +AsyncCleaner::retrieve_backref_mappings_ret +AsyncCleaner::retrieve_backref_mappings( paddr_t start_paddr, paddr_t end_paddr) { @@ -858,9 +858,9 @@ SegmentCleaner::retrieve_backref_mappings( }); } -SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() +AsyncCleaner::gc_reclaim_space_ret AsyncCleaner::gc_reclaim_space() { - LOG_PREFIX(SegmentCleaner::gc_reclaim_space); + LOG_PREFIX(AsyncCleaner::gc_reclaim_space); if (!reclaim_state) { segment_id_t seg_id = get_next_reclaim_segment(); auto &segment_info = segments[seg_id]; @@ -912,7 +912,7 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() "reclaim_space", [this, &backref_extents, &backrefs, &seq, &del_backrefs, &reclaimed, &pin_list](auto &t) { - LOG_PREFIX(SegmentCleaner::gc_reclaim_space); + LOG_PREFIX(AsyncCleaner::gc_reclaim_space); DEBUGT("{} backrefs, {} del_backrefs, {} pins", t, backrefs.size(), del_backrefs.size(), pin_list.size()); for (auto &br : backrefs) { @@ -981,7 +981,7 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() }); }).safe_then( [&reclaimed, this, pavail_ratio, start, &runs] { - LOG_PREFIX(SegmentCleaner::gc_reclaim_space); + LOG_PREFIX(AsyncCleaner::gc_reclaim_space); #ifndef NDEBUG auto ndel_backrefs = backref_manager.get_cached_backref_removals_in_range( @@ -1010,9 +1010,9 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() }); } -SegmentCleaner::mount_ret SegmentCleaner::mount() +AsyncCleaner::mount_ret AsyncCleaner::mount() { - LOG_PREFIX(SegmentCleaner::mount); + LOG_PREFIX(AsyncCleaner::mount); const auto& sms = sm_group->get_segment_managers(); INFO("{} segment managers", sms.size()); init_complete = false; @@ -1097,7 +1097,7 @@ SegmentCleaner::mount_ret SegmentCleaner::mount() }); } -SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( +AsyncCleaner::scan_extents_ret AsyncCleaner::scan_nonfull_segment( const segment_header_t& header, scan_extents_ret_bare& segment_set, segment_id_t segment_id) @@ -1114,7 +1114,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( const record_group_header_t& header, const bufferlist& mdbuf ) mutable -> SegmentManagerGroup::scan_valid_records_ertr::future<> { - LOG_PREFIX(SegmentCleaner::scan_nonfull_segment); + LOG_PREFIX(AsyncCleaner::scan_nonfull_segment); if (segment_header.get_type() == segment_type_t::OOL) { DEBUG("out-of-line segment {}, decodeing {} records", segment_id, @@ -1130,7 +1130,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( mod_time_point_t ctime = header.commit_time; auto commit_type = header.commit_type; if (!ctime) { - ERROR("SegmentCleaner::scan_nonfull_segment: extent {} 0 commit_time", + ERROR("AsyncCleaner::scan_nonfull_segment: extent {} 0 commit_time", ctime); ceph_abort("0 commit_time"); } @@ -1184,12 +1184,12 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( }); } -SegmentCleaner::release_ertr::future<> -SegmentCleaner::maybe_release_segment(Transaction &t) +AsyncCleaner::release_ertr::future<> +AsyncCleaner::maybe_release_segment(Transaction &t) { auto to_release = t.get_segment_to_release(); if (to_release != NULL_SEG_ID) { - LOG_PREFIX(SegmentCleaner::maybe_release_segment); + LOG_PREFIX(AsyncCleaner::maybe_release_segment); INFOT("releasing segment {}", t, to_release); return sm_group->release_segment(to_release ).safe_then([this, FNAME, &t, to_release] { @@ -1215,9 +1215,9 @@ SegmentCleaner::maybe_release_segment(Transaction &t) } } -void SegmentCleaner::complete_init() +void AsyncCleaner::complete_init() { - LOG_PREFIX(SegmentCleaner::complete_init); + LOG_PREFIX(AsyncCleaner::complete_init); if (disable_trim) { init_complete = true; return; @@ -1228,14 +1228,14 @@ void SegmentCleaner::complete_init() gc_process.start(); } -void SegmentCleaner::mark_space_used( +void AsyncCleaner::mark_space_used( paddr_t addr, extent_len_t len, time_point last_modified, time_point last_rewritten, bool init_scan) { - LOG_PREFIX(SegmentCleaner::mark_space_used); + LOG_PREFIX(AsyncCleaner::mark_space_used); if (addr.get_addr_type() != addr_types_t::SEGMENT) { return; } @@ -1270,11 +1270,11 @@ void SegmentCleaner::mark_space_used( space_tracker->get_usage(seg_addr.get_segment_id())); } -void SegmentCleaner::mark_space_free( +void AsyncCleaner::mark_space_free( paddr_t addr, extent_len_t len) { - LOG_PREFIX(SegmentCleaner::mark_space_free); + LOG_PREFIX(AsyncCleaner::mark_space_free); if (!init_complete) { return; } @@ -1304,9 +1304,9 @@ void SegmentCleaner::mark_space_free( space_tracker->get_usage(seg_addr.get_segment_id())); } -segment_id_t SegmentCleaner::get_next_reclaim_segment() const +segment_id_t AsyncCleaner::get_next_reclaim_segment() const { - LOG_PREFIX(SegmentCleaner::get_next_reclaim_segment); + LOG_PREFIX(AsyncCleaner::get_next_reclaim_segment); segment_id_t id = NULL_SEG_ID; double max_benefit_cost = 0; for (auto& [_id, segment_info] : segments) { @@ -1331,9 +1331,9 @@ segment_id_t SegmentCleaner::get_next_reclaim_segment() const } } -void SegmentCleaner::log_gc_state(const char *caller) const +void AsyncCleaner::log_gc_state(const char *caller) const { - LOG_PREFIX(SegmentCleaner::log_gc_state); + LOG_PREFIX(AsyncCleaner::log_gc_state); if (LOCAL_LOGGER.is_enabled(seastar::log_level::debug) && !disable_trim) { DEBUG( @@ -1382,7 +1382,7 @@ void SegmentCleaner::log_gc_state(const char *caller) const } seastar::future<> -SegmentCleaner::reserve_projected_usage(std::size_t projected_usage) +AsyncCleaner::reserve_projected_usage(std::size_t projected_usage) { if (disable_trim) { return seastar::now(); @@ -1427,7 +1427,7 @@ SegmentCleaner::reserve_projected_usage(std::size_t projected_usage) }); } -void SegmentCleaner::release_projected_usage(std::size_t projected_usage) +void AsyncCleaner::release_projected_usage(std::size_t projected_usage) { if (disable_trim) return; ceph_assert(init_complete); diff --git a/src/crimson/os/seastore/segment_cleaner.h b/src/crimson/os/seastore/async_cleaner.h similarity index 99% rename from src/crimson/os/seastore/segment_cleaner.h rename to src/crimson/os/seastore/async_cleaner.h index c28e7b3686ea..0f2ded6bc435 100644 --- a/src/crimson/os/seastore/segment_cleaner.h +++ b/src/crimson/os/seastore/async_cleaner.h @@ -467,7 +467,7 @@ public: }; -class SegmentCleaner : public SegmentProvider { +class AsyncCleaner : public SegmentProvider { public: using time_point = seastar::lowres_system_clock::time_point; using duration = seastar::lowres_system_clock::duration; @@ -707,12 +707,12 @@ private: * disable_trim * * added to enable unit testing of CircularBoundedJournal before - * proper support is added to SegmentCleaner. + * proper support is added to AsyncCleaner. * Should be removed once proper support is added. TODO */ bool disable_trim = false; public: - SegmentCleaner( + AsyncCleaner( config_t config, SegmentManagerGroupRef&& sm_group, BackrefManager &backref_manager, @@ -978,7 +978,7 @@ private: class GCProcess { std::optional process_join; - SegmentCleaner &cleaner; + AsyncCleaner &cleaner; std::optional> blocking; @@ -1008,7 +1008,7 @@ private: }); } public: - GCProcess(SegmentCleaner &cleaner) : cleaner(cleaner) {} + GCProcess(AsyncCleaner &cleaner) : cleaner(cleaner) {} void start() { ceph_assert(is_stopping()); @@ -1291,6 +1291,6 @@ private: } } }; -using SegmentCleanerRef = std::unique_ptr; +using AsyncCleanerRef = std::unique_ptr; } diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc index ee128db1d856..dc7fdffa43ef 100644 --- a/src/crimson/os/seastore/cache.cc +++ b/src/crimson/os/seastore/cache.cc @@ -10,7 +10,7 @@ #include "crimson/os/seastore/logging.h" #include "crimson/common/config_proxy.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" // included for get_extent_by_type #include "crimson/os/seastore/collection_manager/collection_flat_node.h" @@ -1371,7 +1371,7 @@ void Cache::complete_commit( Transaction &t, paddr_t final_block_start, journal_seq_t seq, - SegmentCleaner *cleaner) + AsyncCleaner *cleaner) { LOG_PREFIX(Cache::complete_commit); SUBTRACET(seastore_t, "final_block_start={}, seq={}", diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h index 081dd49743de..3560406c4ebb 100644 --- a/src/crimson/os/seastore/cache.h +++ b/src/crimson/os/seastore/cache.h @@ -26,7 +26,7 @@ class BtreeBackrefManager; namespace crimson::os::seastore { class BackrefManager; -class SegmentCleaner; +class AsyncCleaner; struct backref_buf_entry_t { backref_buf_entry_t( @@ -747,7 +747,7 @@ public: Transaction &t, ///< [in, out] current transaction paddr_t final_block_start, ///< [in] offset of initial block journal_seq_t seq, ///< [in] journal commit seq - SegmentCleaner *cleaner=nullptr ///< [out] optional segment stat listener + AsyncCleaner *cleaner=nullptr ///< [out] optional segment stat listener ); /** diff --git a/src/crimson/os/seastore/journal/segment_allocator.cc b/src/crimson/os/seastore/journal/segment_allocator.cc index 0ea508b31517..2716228531d4 100644 --- a/src/crimson/os/seastore/journal/segment_allocator.cc +++ b/src/crimson/os/seastore/journal/segment_allocator.cc @@ -6,7 +6,7 @@ #include #include "crimson/os/seastore/logging.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" SET_SUBSYS(seastore_journal); diff --git a/src/crimson/os/seastore/journal/segmented_journal.h b/src/crimson/os/seastore/journal/segmented_journal.h index 46c3675bdf1f..a97db1b74ce6 100644 --- a/src/crimson/os/seastore/journal/segmented_journal.h +++ b/src/crimson/os/seastore/journal/segmented_journal.h @@ -9,7 +9,7 @@ #include "include/buffer.h" #include "include/denc.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/journal.h" #include "crimson/os/seastore/segment_manager_group.h" #include "crimson/os/seastore/ordering_handle.h" diff --git a/src/crimson/os/seastore/seastore.cc b/src/crimson/os/seastore/seastore.cc index 2d0428e8f0bf..a07bd50ba560 100644 --- a/src/crimson/os/seastore/seastore.cc +++ b/src/crimson/os/seastore/seastore.cc @@ -23,7 +23,7 @@ #include "crimson/os/futurized_collection.h" #include "crimson/os/seastore/backref_manager.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/collection_manager/flat_collection_manager.h" #include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h" #include "crimson/os/seastore/omap_manager/btree/btree_omap_manager.h" diff --git a/src/crimson/os/seastore/segment_seq_allocator.h b/src/crimson/os/seastore/segment_seq_allocator.h index 7bbca15572a7..e4a864a7b3b6 100644 --- a/src/crimson/os/seastore/segment_seq_allocator.h +++ b/src/crimson/os/seastore/segment_seq_allocator.h @@ -7,7 +7,7 @@ #include "crimson/os/seastore/seastore_types.h" namespace crimson::os::seastore { -class SegmentCleaner; +class AsyncCleaner; } namespace crimson::os::seastore::journal { @@ -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 SegmentCleaner; + friend class AsyncCleaner; }; using SegmentSeqAllocatorRef = diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index 2b89fe45e198..0a7d316235a9 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -23,23 +23,23 @@ SET_SUBSYS(seastore_tm); namespace crimson::os::seastore { TransactionManager::TransactionManager( - SegmentCleanerRef _segment_cleaner, + AsyncCleanerRef _async_cleaner, JournalRef _journal, CacheRef _cache, LBAManagerRef _lba_manager, ExtentPlacementManagerRef &&epm, BackrefManagerRef&& backref_manager, tm_make_config_t config) - : segment_cleaner(std::move(_segment_cleaner)), + : async_cleaner(std::move(_async_cleaner)), cache(std::move(_cache)), lba_manager(std::move(_lba_manager)), journal(std::move(_journal)), epm(std::move(epm)), backref_manager(std::move(backref_manager)), - sm_group(*segment_cleaner->get_segment_manager_group()), + sm_group(*async_cleaner->get_segment_manager_group()), config(config) { - segment_cleaner->set_extent_callback(this); + async_cleaner->set_extent_callback(this); journal->set_write_pipeline(&write_pipeline); } @@ -47,11 +47,11 @@ TransactionManager::mkfs_ertr::future<> TransactionManager::mkfs() { LOG_PREFIX(TransactionManager::mkfs); INFO("enter"); - return segment_cleaner->mount( + return async_cleaner->mount( ).safe_then([this] { return journal->open_for_write(); }).safe_then([this](auto) { - segment_cleaner->init_mkfs(); + async_cleaner->init_mkfs(); return epm->open(); }).safe_then([this, FNAME]() { return with_transaction_intr( @@ -88,7 +88,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() LOG_PREFIX(TransactionManager::mount); INFO("enter"); cache->init(); - return segment_cleaner->mount( + return async_cleaner->mount( ).safe_then([this] { return journal->replay( [this]( @@ -98,7 +98,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() auto last_modified) { auto start_seq = offsets.write_result.start_seq; - segment_cleaner->update_journal_tail_target( + async_cleaner->update_journal_tail_target( cache->get_oldest_dirty_from().value_or(start_seq), cache->get_oldest_backref_dirty_from().value_or(start_seq)); return cache->replay_delta( @@ -124,8 +124,8 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() else return lba_manager->init_cached_extent(t, e); }).si_then([this, FNAME, &t] { - assert(segment_cleaner->debug_check_space( - *segment_cleaner->get_empty_space_tracker())); + assert(async_cleaner->debug_check_space( + *async_cleaner->get_empty_space_tracker())); return backref_manager->scan_mapped_space( t, [this, FNAME, &t]( @@ -141,7 +141,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() len); if (addr.is_real() && !backref_manager->backref_should_be_removed(addr)) { - segment_cleaner->mark_space_used( + async_cleaner->mark_space_used( addr, len , seastar::lowres_system_clock::time_point(), @@ -163,7 +163,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() auto &backrefs = backref_manager->get_cached_backrefs(); DEBUG("marking {} backrefs used", backrefs.size()); for (auto &backref : backrefs) { - segment_cleaner->mark_space_used( + async_cleaner->mark_space_used( backref.paddr, backref.len, seastar::lowres_system_clock::time_point(), @@ -179,7 +179,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() }).safe_then([this] { return epm->open(); }).safe_then([FNAME, this] { - segment_cleaner->complete_init(); + async_cleaner->complete_init(); INFO("completed"); }).handle_error( mount_ertr::pass_further{}, @@ -192,7 +192,7 @@ TransactionManager::mount_ertr::future<> TransactionManager::mount() TransactionManager::close_ertr::future<> TransactionManager::close() { LOG_PREFIX(TransactionManager::close); INFO("enter"); - return segment_cleaner->stop( + return async_cleaner->stop( ).then([this] { return cache->close(); }).safe_then([this] { @@ -314,12 +314,12 @@ TransactionManager::submit_transaction( size_t projected_usage = t.get_allocation_size(); SUBTRACET(seastore_t, "waiting for projected_usage: {}", t, projected_usage); return trans_intr::make_interruptible( - segment_cleaner->reserve_projected_usage(projected_usage) + async_cleaner->reserve_projected_usage(projected_usage) ).then_interruptible([this, &t] { return submit_transaction_direct(t); }).finally([this, FNAME, projected_usage, &t] { SUBTRACET(seastore_t, "releasing projected_usage: {}", t, projected_usage); - segment_cleaner->release_projected_usage(projected_usage); + async_cleaner->release_projected_usage(projected_usage); }); }); } @@ -365,7 +365,7 @@ TransactionManager::submit_transaction_direct( if (seq_to_trim && *seq_to_trim != JOURNAL_SEQ_NULL) { cache->trim_backref_bufs(*seq_to_trim); } - auto record = cache->prepare_record(tref, segment_cleaner.get()); + auto record = cache->prepare_record(tref, async_cleaner.get()); tref.get_handle().maybe_release_collection_lock(); @@ -379,7 +379,7 @@ TransactionManager::submit_transaction_direct( tref, submit_result.record_block_base, start_seq, - segment_cleaner.get()); + async_cleaner.get()); std::vector lba_to_clear; std::vector backref_to_clear; @@ -409,10 +409,10 @@ TransactionManager::submit_transaction_direct( lba_manager->complete_transaction(tref, lba_to_clear, lba_to_link); backref_manager->complete_transaction(tref, backref_to_clear, backref_to_link); - segment_cleaner->update_journal_tail_target( + async_cleaner->update_journal_tail_target( cache->get_oldest_dirty_from().value_or(start_seq), cache->get_oldest_backref_dirty_from().value_or(start_seq)); - return segment_cleaner->maybe_release_segment(tref); + return async_cleaner->maybe_release_segment(tref); }).safe_then([FNAME, &tref] { SUBTRACET(seastore_t, "completed", tref); return tref.get_handle().complete(); @@ -486,7 +486,7 @@ TransactionManager::rewrite_logical_extent( /* This update_mapping is, strictly speaking, unnecessary for delayed_alloc * extents since we're going to do it again once we either do the ool write - * or allocate a relative inline addr. TODO: refactor SegmentCleaner to + * or allocate a relative inline addr. TODO: refactor AsyncCleaner to * avoid this complication. */ return lba_manager->update_mapping( t, @@ -647,15 +647,15 @@ TransactionManagerRef make_transaction_manager(tm_make_config_t config) auto backref_manager = create_backref_manager(*sms, *cache); bool cleaner_is_detailed; - SegmentCleaner::config_t cleaner_config; + AsyncCleaner::config_t cleaner_config; if (config.is_test) { cleaner_is_detailed = true; - cleaner_config = SegmentCleaner::config_t::get_test(); + cleaner_config = AsyncCleaner::config_t::get_test(); } else { cleaner_is_detailed = false; - cleaner_config = SegmentCleaner::config_t::get_default(); + cleaner_config = AsyncCleaner::config_t::get_default(); } - auto segment_cleaner = std::make_unique( + auto async_cleaner = std::make_unique( cleaner_config, std::move(sms), *backref_manager, @@ -663,20 +663,20 @@ TransactionManagerRef make_transaction_manager(tm_make_config_t config) JournalRef journal; if (config.j_type == journal_type_t::SEGMENT_JOURNAL) { - journal = journal::make_segmented(*segment_cleaner); + journal = journal::make_segmented(*async_cleaner); } else { journal = journal::make_circularbounded( nullptr, ""); - segment_cleaner->set_disable_trim(true); + async_cleaner->set_disable_trim(true); ERROR("disabling journal trimming since support for CircularBoundedJournal\ hasn't been added yet"); } epm->init_ool_writers( - *segment_cleaner, - segment_cleaner->get_ool_segment_seq_allocator()); + *async_cleaner, + async_cleaner->get_ool_segment_seq_allocator()); return std::make_unique( - std::move(segment_cleaner), + std::move(async_cleaner), std::move(journal), std::move(cache), std::move(lba_manager), diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h index a02b8bb21dda..8661297cf4bb 100644 --- a/src/crimson/os/seastore/transaction_manager.h +++ b/src/crimson/os/seastore/transaction_manager.h @@ -21,7 +21,7 @@ #include "crimson/osd/exceptions.h" #include "crimson/os/seastore/logging.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/seastore_types.h" #include "crimson/os/seastore/cache.h" #include "crimson/os/seastore/lba_manager.h" @@ -103,13 +103,13 @@ auto repeat_eagain(F &&f) { * Abstraction hiding reading and writing to persistence. * Exposes transaction based interface with read isolation. */ -class TransactionManager : public SegmentCleaner::ExtentCallbackInterface { +class TransactionManager : public AsyncCleaner::ExtentCallbackInterface { public: using base_ertr = Cache::base_ertr; using base_iertr = Cache::base_iertr; TransactionManager( - SegmentCleanerRef segment_cleaner, + AsyncCleanerRef async_cleaner, JournalRef journal, CacheRef cache, LBAManagerRef lba_manager, @@ -423,8 +423,8 @@ public: using submit_transaction_iertr = base_iertr; submit_transaction_iertr::future<> submit_transaction(Transaction &); - /// SegmentCleaner::ExtentCallbackInterface - using SegmentCleaner::ExtentCallbackInterface::submit_transaction_direct_ret; + /// AsyncCleaner::ExtentCallbackInterface + using AsyncCleaner::ExtentCallbackInterface::submit_transaction_direct_ret; submit_transaction_direct_ret submit_transaction_direct( Transaction &t, std::optional seq_to_trim = std::nullopt) final; @@ -438,18 +438,18 @@ public: */ seastar::future<> flush(OrderingHandle &handle); - using SegmentCleaner::ExtentCallbackInterface::get_next_dirty_extents_ret; + using AsyncCleaner::ExtentCallbackInterface::get_next_dirty_extents_ret; get_next_dirty_extents_ret get_next_dirty_extents( Transaction &t, journal_seq_t seq, size_t max_bytes) final; - using SegmentCleaner::ExtentCallbackInterface::rewrite_extent_ret; + using AsyncCleaner::ExtentCallbackInterface::rewrite_extent_ret; rewrite_extent_ret rewrite_extent( Transaction &t, CachedExtentRef extent) final; - using SegmentCleaner::ExtentCallbackInterface::get_extent_if_live_ret; + using AsyncCleaner::ExtentCallbackInterface::get_extent_if_live_ret; get_extent_if_live_ret get_extent_if_live( Transaction &t, extent_types_t type, @@ -577,7 +577,7 @@ public: } store_statfs_t store_stat() const { - return segment_cleaner->stat(); + return async_cleaner->stat(); } void add_device(Device* dev, bool is_primary) { @@ -598,7 +598,7 @@ public: private: friend class Transaction; - SegmentCleanerRef segment_cleaner; + AsyncCleanerRef async_cleaner; CacheRef cache; LBAManagerRef lba_manager; JournalRef journal; @@ -614,8 +614,8 @@ private: LogicalCachedExtentRef extent); public: // Testing interfaces - auto get_segment_cleaner() { - return segment_cleaner.get(); + auto get_async_cleaner() { + return async_cleaner.get(); } auto get_lba_manager() { diff --git a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc index 892e5f780e95..0da0cce18441 100644 --- a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc +++ b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc @@ -112,7 +112,7 @@ struct fltree_onode_manager_test_t auto t = create_mutate_transaction(); std::invoke(f, *t); submit_transaction(std::move(t)); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } template diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc index 3d890c27683a..b00db5e8a6df 100644 --- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc +++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc @@ -1591,7 +1591,7 @@ TEST_F(d_seastore_tm_test_t, 6_random_tree_insert_erase) auto t = create_mutate_transaction(); INTR(tree->bootstrap, *t).unsafe_get(); submit_transaction(std::move(t)); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } // test insert @@ -1599,7 +1599,7 @@ TEST_F(d_seastore_tm_test_t, 6_random_tree_insert_erase) auto t = create_mutate_transaction(); INTR(tree->insert, *t).unsafe_get(); submit_transaction(std::move(t)); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } { auto t = create_read_transaction(); @@ -1623,7 +1623,7 @@ TEST_F(d_seastore_tm_test_t, 6_random_tree_insert_erase) auto size = kvs.size() / 4 * 3; INTR_R(tree->erase, *t, size).unsafe_get(); submit_transaction(std::move(t)); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } { auto t = create_read_transaction(); @@ -1646,7 +1646,7 @@ TEST_F(d_seastore_tm_test_t, 6_random_tree_insert_erase) auto size = kvs.size(); INTR_R(tree->erase, *t, size).unsafe_get(); submit_transaction(std::move(t)); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } { auto t = create_read_transaction(); @@ -1703,7 +1703,7 @@ TEST_F(d_seastore_tm_test_t, 7_tree_insert_erase_eagain) }); }); }).unsafe_get0(); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); // insert logger().warn("start inserting {} kvs ...", kvs.size()); @@ -1723,7 +1723,7 @@ TEST_F(d_seastore_tm_test_t, 7_tree_insert_erase_eagain) }); }); }).unsafe_get0(); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); ++iter; } } @@ -1769,7 +1769,7 @@ TEST_F(d_seastore_tm_test_t, 7_tree_insert_erase_eagain) }); }); }).unsafe_get0(); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); ++iter; } kvs.erase_from_random(kvs.random_begin(), kvs.random_end()); diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc index 91600ca10b8c..a67b0aa70d43 100644 --- a/src/test/crimson/seastore/test_seastore_journal.cc +++ b/src/test/crimson/seastore/test_seastore_journal.cc @@ -6,7 +6,7 @@ #include #include "crimson/common/log.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/journal.h" #include "crimson/os/seastore/segment_manager/ephemeral.h" diff --git a/src/test/crimson/seastore/test_transaction_manager.cc b/src/test/crimson/seastore/test_transaction_manager.cc index f5c564fa4b0d..4b6c86e142f5 100644 --- a/src/test/crimson/seastore/test_transaction_manager.cc +++ b/src/test/crimson/seastore/test_transaction_manager.cc @@ -8,7 +8,7 @@ #include "test/crimson/gtest_seastar.h" #include "test/crimson/seastore/transaction_manager_test_state.h" -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/cache.h" #include "crimson/os/seastore/transaction_manager.h" #include "crimson/os/seastore/segment_manager/ephemeral.h" @@ -396,7 +396,7 @@ struct transaction_manager_test_t : bool check_usage() { auto t = create_weak_test_transaction(); - SpaceTrackerIRef tracker(segment_cleaner->get_empty_space_tracker()); + SpaceTrackerIRef tracker(async_cleaner->get_empty_space_tracker()); with_trans_intr( *t.t, [this, &tracker](auto &t) { @@ -427,7 +427,7 @@ struct transaction_manager_test_t : return seastar::now(); }); }).unsafe_get0(); - return segment_cleaner->debug_check_space(*tracker); + return async_cleaner->debug_check_space(*tracker); } void replay() { @@ -578,7 +578,7 @@ struct transaction_manager_test_t : "try_submit_transaction hit invalid error" } ).then([this](auto ret) { - return segment_cleaner->run_until_halt().then([ret] { return ret; }); + return async_cleaner->run_until_halt().then([ret] { return ret; }); }).get0(); if (success) { @@ -628,7 +628,7 @@ struct transaction_manager_test_t : }); }); }).safe_then([this]() { - return segment_cleaner->run_until_halt(); + return async_cleaner->run_until_halt(); }).handle_error( crimson::ct_error::assert_all{ "Invalid error in SeaStore::list_collections" diff --git a/src/test/crimson/seastore/transaction_manager_test_state.h b/src/test/crimson/seastore/transaction_manager_test_state.h index b712effaf4be..19b5b08cdf3a 100644 --- a/src/test/crimson/seastore/transaction_manager_test_state.h +++ b/src/test/crimson/seastore/transaction_manager_test_state.h @@ -6,7 +6,7 @@ #include #include -#include "crimson/os/seastore/segment_cleaner.h" +#include "crimson/os/seastore/async_cleaner.h" #include "crimson/os/seastore/cache.h" #include "crimson/os/seastore/transaction_manager.h" #include "crimson/os/seastore/segment_manager/ephemeral.h" @@ -146,7 +146,7 @@ protected: LBAManager *lba_manager; BackrefManager *backref_manager; Cache* cache; - SegmentCleaner *segment_cleaner; + AsyncCleaner *async_cleaner; TMTestState() : EphemeralTestState(1) {} @@ -165,14 +165,14 @@ protected: tm->add_device(sec_sm.get(), false); } } - segment_cleaner = tm->get_segment_cleaner(); + async_cleaner = tm->get_async_cleaner(); lba_manager = tm->get_lba_manager(); backref_manager = tm->get_backref_manager(); cache = tm->get_cache(); } virtual void _destroy() override { - segment_cleaner = nullptr; + async_cleaner = nullptr; lba_manager = nullptr; tm.reset(); } @@ -191,9 +191,9 @@ protected: ).handle_error( crimson::ct_error::assert_all{"Error in mount"} ).then([this] { - return segment_cleaner->stop(); + return async_cleaner->stop(); }).then([this] { - return segment_cleaner->run_until_halt(); + return async_cleaner->run_until_halt(); }); } @@ -251,7 +251,7 @@ protected: void submit_transaction(TransactionRef t) { submit_transaction_fut(*t).unsafe_get0(); - segment_cleaner->run_until_halt().get0(); + async_cleaner->run_until_halt().get0(); } }; -- 2.47.3