{
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 {
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,
config.validate();
}
-void AsyncCleaner::register_metrics()
+void SegmentCleaner::register_metrics()
{
namespace sm = seastar::metrics;
stats.segment_util.buckets.resize(UTIL_BUCKETS);
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")),
});
}
-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
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];
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
(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<CachedExtentRef> &backref_extents,
const backref_pin_list_t &pin_list,
std::size_t &reclaimed,
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<CachedExtentRef>(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(
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,
});
}
-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();
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);
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());
});
}
-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({
});
}
-bool AsyncCleaner::check_usage()
+bool SegmentCleaner::check_usage()
{
SpaceTrackerIRef tracker(space_tracker->make_empty());
extent_callback->with_transaction_weak(
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) {
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) {
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;
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;
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);
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;
}
}
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();
}
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<AsyncCleaner>;
+
+std::ostream &operator<<(
+ std::ostream &, const AsyncCleaner::stat_printer_t &);
+
+class SegmentCleaner;
+using SegmentCleanerRef = std::unique_ptr<SegmentCleaner>;
+
+class SegmentCleaner : public SegmentProvider, public AsyncCleaner {
+public:
/// Config
struct config_t {
/// Ratio of maximum available space to disable reclaiming.
}
};
-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,
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<SegmentCleaner>(
+ config, std::move(sm_group), backref_manager, detailed);
}
/*
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;
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;
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;
);
}
- 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:
/*
ool_segment_seq_allocator->set_next_segment_seq(seq);
}
}
-};
-using AsyncCleanerRef = std::unique_ptr<AsyncCleaner>;
-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;
+};
}
writer_refs.clear();
ceph_assert(RECLAIM_GENERATIONS > 0);
+ auto segment_cleaner = dynamic_cast<SegmentCleaner*>(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<SegmentedOolWriter>(
- 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<SegmentedOolWriter>(
- 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);
}
// 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;
"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 {
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"))
});
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();
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;
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 =
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);
}
*backref_manager, trimmer_config,
journal_type, roll_start, roll_size);
- auto async_cleaner = std::make_unique<AsyncCleaner>(
+ 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(
"");
}
- 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<TransactionManager>(
projects / ceph.git / commitdiff