#include "crimson/os/seastore/journal/segment_allocator.h"
#include "crimson/os/seastore/journal/record_submitter.h"
#include "crimson/os/seastore/transaction.h"
+#include "crimson/os/seastore/extent_pinboard.h"
+#include "crimson/os/seastore/logical_bucket.h"
#include "crimson/os/seastore/random_block_manager.h"
#include "crimson/os/seastore/random_block_manager/block_rb_manager.h"
#include "crimson/os/seastore/randomblock_manager_group.h"
cold_tier_generations, hot_tier_generations);
}
- void init(JournalTrimmerImplRef &&, AsyncCleanerRef &&, AsyncCleanerRef &&);
+ void init(JournalTrimmerImplRef &&, AsyncCleanerRef &&, AsyncCleanerRef &&,
+ ExtentPinboard *pinboard);
SegmentSeqAllocator &get_ool_segment_seq_allocator() const {
return *ool_segment_seq_allocator;
bool report_detail,
double seconds) const;
+ LogicalBucket *get_logical_bucket() {
+ return background_process.get_logical_bucket();
+ }
+
using mount_ertr = crimson::errorator<
crimson::ct_error::input_output_error>;
using mount_ret = mount_ertr::future<>;
void init(JournalTrimmerImplRef &&_trimmer,
AsyncCleanerRef &&_cleaner,
AsyncCleanerRef &&_cold_cleaner,
- rewrite_gen_t hot_tier_generations) {
+ rewrite_gen_t hot_tier_generations,
+ ExtentPinboard *_pinboard) {
trimmer = std::move(_trimmer);
trimmer->set_background_callback(this);
main_cleaner = std::move(_cleaner);
cleaners_by_device_id[id] = cold_cleaner.get();
}
+ using crimson::common::get_conf;
eviction_state.init(
crimson::common::get_conf<double>(
"seastore_multiple_tiers_stop_evict_ratio"),
crimson::common::get_conf<double>(
"seastore_multiple_tiers_fast_evict_ratio"),
hot_tier_generations);
+
+ pinboard = _pinboard;
+ ceph_assert(pinboard != nullptr);
+ pinboard->set_background_callback(this);
+
+ logical_bucket = create_logical_bucket(
+ get_conf<Option::size_t>("seastore_logical_bucket_capacity"),
+ get_conf<Option::size_t>("seastore_logical_bucket_proceed_size_per_cycle"));
}
}
+ LogicalBucket *get_logical_bucket() {
+ return logical_bucket.get();
+ }
+
backend_type_t get_backend_type() const {
return trimmer->get_backend_type();
}
main_cleaner->set_extent_callback(cb);
if (has_cold_tier()) {
cold_cleaner->set_extent_callback(cb);
+ pinboard->set_extent_callback(cb);
+ logical_bucket->set_extent_callback(cb);
}
}
bool main_cleaner_should_fast_evict() const {
return has_cold_tier() &&
- main_cleaner->can_clean_space() &&
+ (main_cleaner->can_clean_space() ||
+ (logical_bucket && logical_bucket->could_demote())) &&
eviction_state.is_fast_mode();
}
JournalTrimmerImplRef trimmer;
AsyncCleanerRef main_cleaner;
+ ExtentPinboard *pinboard = nullptr;
+ LogicalBucketRef logical_bucket;
/*
* cold tier (optional, see has_cold_tier())
{
epm->set_extent_callback(this);
journal->set_write_pipeline(&write_pipeline);
+ if (epm->has_cold_tier()) {
+ logical_bucket = epm->get_logical_bucket();
+ assert(support_logical_bucket());
+ }
}
TransactionManager::mkfs_ertr::future<> TransactionManager::mkfs()
epm->init(std::move(journal_trimmer),
std::move(cleaner),
- std::move(cold_segment_cleaner));
+ std::move(cold_segment_cleaner),
+ cache->get_extent_pinboard());
epm->set_primary_device(primary_device);
INFO("main backend type: {}, cold tier: {}",