From: Yingxin Cheng Date: Fri, 22 Jul 2022 08:54:25 +0000 (+0800) Subject: crimson/os/seastore: cleanup, consolidate alloc_tail/dirty_tail naming X-Git-Tag: v18.0.0~426^2~8 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=cc3ad28274916a2f7063ab8b918a0e1f8f5e15ef;p=ceph.git crimson/os/seastore: cleanup, consolidate alloc_tail/dirty_tail naming Signed-off-by: Yingxin Cheng --- diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc index c64adcd88c37..776e32b394ed 100644 --- a/src/crimson/os/seastore/async_cleaner.cc +++ b/src/crimson/os/seastore/async_cleaner.cc @@ -688,7 +688,7 @@ void AsyncCleaner::close_segment(segment_id_t segment) seg_info); } -AsyncCleaner::trim_backrefs_ret AsyncCleaner::trim_backrefs( +AsyncCleaner::trim_alloc_ret AsyncCleaner::trim_alloc( Transaction &t, journal_seq_t limit) { @@ -785,20 +785,20 @@ AsyncCleaner::gc_cycle_ret AsyncCleaner::GCProcess::run() AsyncCleaner::gc_cycle_ret AsyncCleaner::do_gc_cycle() { - if (gc_should_trim_backref()) { - return gc_trim_backref(get_alloc_tail_target() + if (gc_should_trim_alloc()) { + return gc_trim_alloc(get_alloc_tail_target() ).safe_then([](auto) { return seastar::now(); }).handle_error( crimson::ct_error::assert_all{ - "GCProcess::run encountered invalid error in gc_trim_backref" + "GCProcess::run encountered invalid error in gc_trim_alloc" } ); - } else if (gc_should_trim_journal()) { - return gc_trim_journal( + } else if (gc_should_trim_dirty()) { + return gc_trim_dirty( ).handle_error( crimson::ct_error::assert_all{ - "GCProcess::run encountered invalid error in gc_trim_journal" + "GCProcess::run encountered invalid error in gc_trim_dirty" } ); } else if (gc_should_reclaim_space()) { @@ -813,50 +813,50 @@ AsyncCleaner::gc_cycle_ret AsyncCleaner::do_gc_cycle() } } -AsyncCleaner::gc_trim_backref_ret -AsyncCleaner::gc_trim_backref(journal_seq_t limit) { +AsyncCleaner::gc_trim_alloc_ret +AsyncCleaner::gc_trim_alloc(journal_seq_t limit) { return seastar::do_with( journal_seq_t(), [this, limit=std::move(limit)](auto &seq) mutable { return repeat_eagain([this, limit=std::move(limit), &seq] { return ecb->with_transaction_intr( - Transaction::src_t::TRIM_BACKREF, - "trim_backref", + Transaction::src_t::CLEANER_TRIM_ALLOC, + "trim_alloc", [this, limit](auto &t) { - return trim_backrefs( + return trim_alloc( t, limit - ).si_then([this, &t, limit](auto trim_backrefs_to) + ).si_then([this, &t, limit](auto trim_alloc_to) -> ExtentCallbackInterface::submit_transaction_direct_iertr::future< journal_seq_t> { - if (trim_backrefs_to != JOURNAL_SEQ_NULL) { + if (trim_alloc_to != JOURNAL_SEQ_NULL) { return ecb->submit_transaction_direct( - t, std::make_optional(trim_backrefs_to) - ).si_then([trim_backrefs_to=std::move(trim_backrefs_to)]() mutable { + t, std::make_optional(trim_alloc_to) + ).si_then([trim_alloc_to=std::move(trim_alloc_to)]() mutable { return seastar::make_ready_future< - journal_seq_t>(std::move(trim_backrefs_to)); + journal_seq_t>(std::move(trim_alloc_to)); }); } return seastar::make_ready_future(std::move(limit)); }); - }).safe_then([&seq](auto trim_backrefs_to) { - seq = std::move(trim_backrefs_to); + }).safe_then([&seq](auto trim_alloc_to) { + seq = std::move(trim_alloc_to); }); }).safe_then([&seq] { - return gc_trim_backref_ertr::make_ready_future< + return gc_trim_alloc_ertr::make_ready_future< journal_seq_t>(std::move(seq)); }); }); } -AsyncCleaner::gc_trim_journal_ret AsyncCleaner::gc_trim_journal() +AsyncCleaner::gc_trim_dirty_ret AsyncCleaner::gc_trim_dirty() { - return gc_trim_backref(get_dirty_tail_target() + return gc_trim_alloc(get_dirty_tail_target() ).safe_then([this](auto seq) { return repeat_eagain([this, seq=std::move(seq)]() mutable { return ecb->with_transaction_intr( - Transaction::src_t::CLEANER_TRIM, - "trim_journal", + Transaction::src_t::CLEANER_TRIM_DIRTY, + "trim_dirty", [this, seq=std::move(seq)](auto& t) { return rewrite_dirty(t, seq @@ -1378,7 +1378,8 @@ void AsyncCleaner::log_gc_state(const char *caller) const "alloc_tail_target {}, " "dirty_tail_target {}, " "tail_limit {}, " - "gc_should_trim_journal {}, ", + "gc_should_trim_dirty {}, " + "gc_should_trim_alloc{}, ", caller, segments.get_num_empty(), segments.get_num_open(), @@ -1400,7 +1401,8 @@ void AsyncCleaner::log_gc_state(const char *caller) const get_alloc_tail_target(), get_dirty_tail_target(), get_tail_limit(), - gc_should_trim_journal() + gc_should_trim_dirty(), + gc_should_trim_alloc() ); } } diff --git a/src/crimson/os/seastore/async_cleaner.h b/src/crimson/os/seastore/async_cleaner.h index 7c2bae392bfd..1ae22517a4b8 100644 --- a/src/crimson/os/seastore/async_cleaner.h +++ b/src/crimson/os/seastore/async_cleaner.h @@ -512,14 +512,14 @@ class AsyncCleaner : public SegmentProvider { public: /// Config struct config_t { - /// Number of minimum journal segments to stop trimming. - size_t target_journal_segments = 0; + /// Number of minimum journal segments to stop trimming dirty. + size_t target_journal_dirty_segments = 0; /// Number of maximum journal segments to block user transactions. size_t max_journal_segments = 0; - /// Number of journal segments the transactions in which can - /// have their corresponding backrefs unmerged - size_t target_backref_inflight_segments = 0; + /// Number of minimum journal segments to stop trimming allocation + /// (having the corresponding backrefs unmerged) + size_t target_journal_alloc_segments = 0; /// Ratio of maximum available space to disable reclaiming. double available_ratio_gc_max = 0; @@ -539,7 +539,8 @@ public: size_t rewrite_backref_bytes_per_cycle = 0; void validate() const { - ceph_assert(max_journal_segments > target_journal_segments); + ceph_assert(max_journal_segments > target_journal_dirty_segments); + ceph_assert(max_journal_segments > target_journal_alloc_segments); ceph_assert(available_ratio_gc_max > available_ratio_hard_limit); ceph_assert(reclaim_bytes_per_cycle > 0); ceph_assert(rewrite_dirty_bytes_per_cycle > 0); @@ -548,9 +549,9 @@ public: static config_t get_default() { return config_t{ - 12, // target_journal_segments + 12, // target_journal_dirty_segments 16, // max_journal_segments - 2, // target_backref_inflight_segments + 2, // target_journal_alloc_segments .15, // available_ratio_gc_max .1, // available_ratio_hard_limit .1, // reclaim_ratio_gc_threshold @@ -562,9 +563,9 @@ public: static config_t get_test() { return config_t{ - 2, // target_journal_segments + 2, // target_journal_dirty_segments 4, // max_journal_segments - 2, // target_backref_inflight_segments + 2, // target_journal_alloc_segments .99, // available_ratio_gc_max .2, // available_ratio_hard_limit .6, // reclaim_ratio_gc_threshold @@ -920,17 +921,17 @@ private: Transaction &t, journal_seq_t limit); - using trim_backrefs_iertr = work_iertr; - using trim_backrefs_ret = trim_backrefs_iertr::future; - trim_backrefs_ret trim_backrefs( + using trim_alloc_iertr = work_iertr; + using trim_alloc_ret = trim_alloc_iertr::future; + trim_alloc_ret trim_alloc( Transaction &t, journal_seq_t limit); journal_seq_t get_dirty_tail_target() const { auto ret = journal_head; ceph_assert(ret != JOURNAL_SEQ_NULL); - if (ret.segment_seq >= config.target_journal_segments) { - ret.segment_seq -= config.target_journal_segments; + if (ret.segment_seq >= config.target_journal_dirty_segments) { + ret.segment_seq -= config.target_journal_dirty_segments; } else { ret.segment_seq = 0; ret.offset = P_ADDR_MIN; @@ -953,8 +954,8 @@ private: journal_seq_t get_alloc_tail_target() const { auto ret = journal_head; ceph_assert(ret != JOURNAL_SEQ_NULL); - if (ret.segment_seq >= config.target_backref_inflight_segments) { - ret.segment_seq -= config.target_backref_inflight_segments; + if (ret.segment_seq >= config.target_journal_alloc_segments) { + ret.segment_seq -= config.target_journal_alloc_segments; } else { ret.segment_seq = 0; ret.offset = P_ADDR_MIN; @@ -1091,13 +1092,13 @@ private: gc_cycle_ret do_gc_cycle(); - using gc_trim_journal_ertr = gc_ertr; - using gc_trim_journal_ret = gc_trim_journal_ertr::future<>; - gc_trim_journal_ret gc_trim_journal(); + using gc_trim_dirty_ertr = gc_ertr; + using gc_trim_dirty_ret = gc_trim_dirty_ertr::future<>; + gc_trim_dirty_ret gc_trim_dirty(); - using gc_trim_backref_ertr = gc_ertr; - using gc_trim_backref_ret = gc_trim_backref_ertr::future; - gc_trim_backref_ret gc_trim_backref(journal_seq_t limit); + using gc_trim_alloc_ertr = gc_ertr; + using gc_trim_alloc_ret = gc_trim_alloc_ertr::future; + gc_trim_alloc_ret gc_trim_alloc(journal_seq_t limit); using gc_reclaim_space_ertr = gc_ertr; using gc_reclaim_space_ret = gc_reclaim_space_ertr::future<>; @@ -1285,16 +1286,11 @@ private: ); } - /** - * gc_should_trim_journal - * - * Encapsulates logic for whether gc should be reclaiming segment space. - */ - bool gc_should_trim_journal() const { + bool gc_should_trim_dirty() const { return get_dirty_tail_target() > journal_dirty_tail; } - bool gc_should_trim_backref() const { + bool gc_should_trim_alloc() const { return get_alloc_tail_target() > journal_alloc_tail; } /** @@ -1306,8 +1302,8 @@ private: if (disable_trim) return false; ceph_assert(init_complete); return gc_should_reclaim_space() - || gc_should_trim_journal() - || gc_should_trim_backref(); + || gc_should_trim_dirty() + || gc_should_trim_alloc(); } void init_mark_segment_closed( diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc index be7bd75cd0c7..ff127f14c47a 100644 --- a/src/crimson/os/seastore/cache.cc +++ b/src/crimson/os/seastore/cache.cc @@ -133,8 +133,8 @@ void Cache::register_metrics() std::map labels_by_src { {src_t::MUTATE, sm::label_instance("src", "MUTATE")}, {src_t::READ, sm::label_instance("src", "READ")}, - {src_t::CLEANER_TRIM, sm::label_instance("src", "CLEANER_TRIM")}, - {src_t::TRIM_BACKREF, sm::label_instance("src", "TRIM_BACKREF")}, + {src_t::CLEANER_TRIM_DIRTY, sm::label_instance("src", "CLEANER_TRIM_DIRTY")}, + {src_t::CLEANER_TRIM_ALLOC, sm::label_instance("src", "CLEANER_TRIM_ALLOC")}, {src_t::CLEANER_RECLAIM, sm::label_instance("src", "CLEANER_RECLAIM")}, }; assert(labels_by_src.size() == (std::size_t)src_t::MAX); @@ -622,12 +622,12 @@ void Cache::register_metrics() // should be consistent with checks in account_conflict() if ((src1 == Transaction::src_t::READ && src2 == Transaction::src_t::READ) || - (src1 == Transaction::src_t::CLEANER_TRIM && - src2 == Transaction::src_t::CLEANER_TRIM) || + (src1 == Transaction::src_t::CLEANER_TRIM_DIRTY && + src2 == Transaction::src_t::CLEANER_TRIM_DIRTY) || (src1 == Transaction::src_t::CLEANER_RECLAIM && src2 == Transaction::src_t::CLEANER_RECLAIM) || - (src1 == Transaction::src_t::TRIM_BACKREF && - src2 == Transaction::src_t::TRIM_BACKREF)) { + (src1 == Transaction::src_t::CLEANER_TRIM_ALLOC && + src2 == Transaction::src_t::CLEANER_TRIM_ALLOC)) { continue; } std::ostringstream oss; @@ -1344,7 +1344,7 @@ record_t Cache::prepare_record( (record.size.get_raw_mdlength() - record.get_delta_size()); auto &rewrite_version_stats = t.get_rewrite_version_stats(); - if (trans_src == Transaction::src_t::CLEANER_TRIM) { + if (trans_src == Transaction::src_t::CLEANER_TRIM_DIRTY) { stats.committed_dirty_version.increment_stat(rewrite_version_stats); } else if (trans_src == Transaction::src_t::CLEANER_RECLAIM) { stats.committed_reclaim_version.increment_stat(rewrite_version_stats); diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h index 254af8395c4e..76fb53708969 100644 --- a/src/crimson/os/seastore/cache.h +++ b/src/crimson/os/seastore/cache.h @@ -1231,12 +1231,12 @@ private: // should be consistent with trans_srcs_invalidated in register_metrics() assert(!(src1 == Transaction::src_t::READ && src2 == Transaction::src_t::READ)); - assert(!(src1 == Transaction::src_t::CLEANER_TRIM && - src2 == Transaction::src_t::CLEANER_TRIM)); + assert(!(src1 == Transaction::src_t::CLEANER_TRIM_DIRTY && + src2 == Transaction::src_t::CLEANER_TRIM_DIRTY)); assert(!(src1 == Transaction::src_t::CLEANER_RECLAIM && src2 == Transaction::src_t::CLEANER_RECLAIM)); - assert(!(src1 == Transaction::src_t::TRIM_BACKREF && - src2 == Transaction::src_t::TRIM_BACKREF)); + assert(!(src1 == Transaction::src_t::CLEANER_TRIM_ALLOC && + src2 == Transaction::src_t::CLEANER_TRIM_ALLOC)); auto src1_value = static_cast(src1); auto src2_value = static_cast(src2); diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc index a6191f7dfbc5..21f7e547efda 100644 --- a/src/crimson/os/seastore/seastore_types.cc +++ b/src/crimson/os/seastore/seastore_types.cc @@ -316,10 +316,10 @@ std::ostream &operator<<(std::ostream &os, transaction_type_t type) return os << "MUTATE"; case transaction_type_t::READ: return os << "READ"; - case transaction_type_t::CLEANER_TRIM: - return os << "CLEANER_TRIM"; - case transaction_type_t::TRIM_BACKREF: - return os << "TRIM_BACKREF"; + case transaction_type_t::CLEANER_TRIM_DIRTY: + return os << "CLEANER_TRIM_DIRTY"; + case transaction_type_t::CLEANER_TRIM_ALLOC: + return os << "CLEANER_TRIM_ALLOC"; case transaction_type_t::CLEANER_RECLAIM: return os << "CLEANER_RECLAIM"; case transaction_type_t::MAX: diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h index c76c85172c61..a745f29e30d2 100644 --- a/src/crimson/os/seastore/seastore_types.h +++ b/src/crimson/os/seastore/seastore_types.h @@ -1555,8 +1555,8 @@ std::ostream &operator<<(std::ostream &out, const segment_tail_t &tail); enum class transaction_type_t : uint8_t { MUTATE = 0, READ, // including weak and non-weak read transactions - CLEANER_TRIM, - TRIM_BACKREF, + CLEANER_TRIM_DIRTY, + CLEANER_TRIM_ALLOC, CLEANER_RECLAIM, MAX }; @@ -1573,7 +1573,7 @@ constexpr bool is_valid_transaction(transaction_type_t type) { } constexpr bool is_cleaner_transaction(transaction_type_t type) { - return (type >= transaction_type_t::CLEANER_TRIM && + return (type >= transaction_type_t::CLEANER_TRIM_DIRTY && type < transaction_type_t::MAX); } diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index 308346136947..a02221de5723 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -325,7 +325,7 @@ TransactionManager::submit_transaction( TransactionManager::submit_transaction_direct_ret TransactionManager::submit_transaction_direct( Transaction &tref, - std::optional seq_to_trim) + std::optional trim_alloc_to) { LOG_PREFIX(TransactionManager::submit_transaction_direct); SUBTRACET(seastore_t, "start", tref); @@ -358,10 +358,10 @@ TransactionManager::submit_transaction_direct( }).si_then([this, FNAME, &tref] { SUBTRACET(seastore_t, "about to prepare", tref); return tref.get_handle().enter(write_pipeline.prepare); - }).si_then([this, FNAME, &tref, seq_to_trim=std::move(seq_to_trim)]() mutable + }).si_then([this, FNAME, &tref, trim_alloc_to=std::move(trim_alloc_to)]() mutable -> submit_transaction_iertr::future<> { - if (seq_to_trim && *seq_to_trim != JOURNAL_SEQ_NULL) { - cache->trim_backref_bufs(*seq_to_trim); + if (trim_alloc_to && *trim_alloc_to != JOURNAL_SEQ_NULL) { + cache->trim_backref_bufs(*trim_alloc_to); } auto record = cache->prepare_record(tref, async_cleaner.get()); @@ -370,8 +370,7 @@ TransactionManager::submit_transaction_direct( SUBTRACET(seastore_t, "about to submit to journal", tref); return journal->submit_record(std::move(record), tref.get_handle() - ).safe_then([this, FNAME, &tref, seq_to_trim=std::move(seq_to_trim)] - (auto submit_result) mutable { + ).safe_then([this, FNAME, &tref](auto submit_result) mutable { SUBDEBUGT(seastore_t, "committed with {}", tref, submit_result); auto start_seq = submit_result.write_result.start_seq; cache->complete_commit(