JournalRef make_segmented(
store_index_t store_index,
SegmentProvider &provider,
- JournalTrimmer &trimmer)
+ JournalTrimmer &trimmer,
+ bool scan_alloc_on_boot)
{
- return std::make_unique<SegmentedJournal>(store_index, provider, trimmer);
+ return std::make_unique<SegmentedJournal>(
+ store_index, provider, trimmer, scan_alloc_on_boot);
}
JournalRef make_circularbounded(
JournalRef make_segmented(
store_index_t store_index,
SegmentProvider &provider,
- JournalTrimmer &trimmer);
+ JournalTrimmer &trimmer,
+ bool scan_alloc_on_boot);
JournalRef make_circularbounded(
store_index_t store_index,
SegmentedJournal::SegmentedJournal(
store_index_t store_index,
SegmentProvider &segment_provider,
- JournalTrimmer &trimmer)
+ JournalTrimmer &trimmer,
+ bool scan_alloc_on_startup)
: store_index(store_index),
segment_seq_allocator(
new SegmentSeqAllocator(segment_type_t::JOURNAL)),
"seastore_journal_batch_preferred_fullness"),
journal_segment_allocator),
sm_group(*segment_provider.get_segment_manager_group()),
- trimmer{trimmer}
+ trimmer{trimmer},
+ scan_alloc_on_startup(scan_alloc_on_startup)
{
}
auto segment_headers = co_await sm_group.find_journal_segment_headers();
INFO("got {} segments", segment_headers.size());
co_await prep_replay_segments(std::move(segment_headers));
- auto d_handler = [&handler, this](
+ alloc_map_t alloc_map;
+ if (scan_alloc_on_startup) {
+ alloc_map = co_await scan_alloc_map();
+ }
+ auto d_handler = [&handler, this, &alloc_map](
const record_locator_t &locator,
const delta_info_t &delta,
sea_time_point modify_time) -> replay_ertr::future<bool> {
+ if (auto it = alloc_map.find(delta.paddr);
+ it != alloc_map.end() &&
+ it->second > locator.write_result.start_seq) {
+ co_return true;
+ }
auto ret = co_await handler(
locator,
delta,
SegmentedJournal(
store_index_t store_index,
SegmentProvider &segment_provider,
- JournalTrimmer &trimmer);
+ JournalTrimmer &trimmer,
+ bool scan_alloc_on_startup);
~SegmentedJournal() {}
JournalTrimmer &get_trimmer() final {
std::size_t num_dirty_deltas = 0;
} stats;
+ const bool scan_alloc_on_startup = false;
using replay_segments_t = std::vector<
std::pair<journal_seq_t, segment_header_t>>;
replay_segments_t replay_segments;
JournalRef journal;
AsyncCleanerRef cold_cleaner = nullptr;
+ bool scan_alloc_on_boot = false;
if (cold_sms) {
assert(!cold_rbs);
}
cold_cleaner = std::move(segment_cleaner);
} else if (cold_rbs) {
+ scan_alloc_on_boot = true;
cold_cleaner = RBMCleaner::create(
store_index,
std::move(cold_rbs),
journal = journal::make_segmented(
store_index,
*segment_cleaner,
- *journal_trimmer);
+ *journal_trimmer,
+ scan_alloc_on_boot);
} else {
cleaner = RBMCleaner::create(
store_index,
segment_manager::get_ephemeral_device_config(0, 1, 0));
}).safe_then([this] {
sms.reset(new SegmentManagerGroup());
- journal = journal::make_segmented(0, *this, *this);
+ journal = journal::make_segmented(0, *this, *this, false);
rewrite_gen_t hot_tier_generations = crimson::common::get_conf<uint64_t>(
"seastore_hot_tier_generations");
rewrite_gen_t cold_tier_generations = crimson::common::get_conf<uint64_t>(
block_size = segment_manager->get_block_size();
sms.reset(new SegmentManagerGroup());
next = segment_id_t(segment_manager->get_device_id(), 0);
- journal = journal::make_segmented(0, *this, *this);
+ journal = journal::make_segmented(0, *this, *this, false);
journal->set_write_pipeline(&pipeline);
sms->add_segment_manager(segment_manager.get());
return journal->open_for_mkfs();
auto replay(T &&f) {
return journal->close(
).safe_then([this, f=std::move(f)]() mutable {
- journal = journal::make_segmented(0, *this, *this);
+ journal = journal::make_segmented(0, *this, *this, false);
journal->set_write_pipeline(&pipeline);
return journal->replay(std::forward<T>(std::move(f)));
}).safe_then([this] {