From d5bd0039b9e2b6a3af58617ea591c29cb726f74b Mon Sep 17 00:00:00 2001 From: mrambacher Date: Wed, 16 Jun 2021 16:50:43 -0700 Subject: [PATCH] Rename ImmutableOptions variables (#8409) Summary: This is the next part of the ImmutableOptions cleanup. After changing the use of ImmutableCFOptions to ImmutableOptions, there were places in the code that had did something like "ImmutableOptions* immutable_cf_options", where "cf" referred to the "old" type. This change simply renames the variables to match the current type. No new functionality is introduced. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8409 Reviewed By: pdillinger Differential Revision: D29166248 Pulled By: mrambacher fbshipit-source-id: 96de97f8e743f5c5160f02246e3ed8269556dc6f --- db/arena_wrapped_db_iter.cc | 16 ++- db/arena_wrapped_db_iter.h | 5 +- db/blob/blob_file_builder.cc | 36 +++---- db/blob/blob_file_builder.h | 2 +- db/blob/blob_file_builder_test.cc | 119 ++++++++++----------- db/blob/blob_file_cache.cc | 10 +- db/blob/blob_file_cache.h | 2 +- db/blob/blob_file_cache_test.cc | 45 ++++---- db/blob/blob_file_reader.cc | 25 +++-- db/blob/blob_file_reader_test.cc | 139 ++++++++++++------------- db/compaction/compaction.h | 4 +- db/compaction/compaction_iterator.h | 6 +- db/compaction/compaction_job.cc | 19 ++-- db/db_impl/db_impl_compaction_flush.cc | 10 +- db/db_iter.cc | 16 +-- db/db_iter.h | 5 +- db/db_iter_test.cc | 124 +++++++++++----------- db/job_context.h | 6 +- db/version_set.cc | 10 +- db/version_set.h | 2 +- db/version_set_test.cc | 12 +-- 21 files changed, 300 insertions(+), 313 deletions(-) diff --git a/db/arena_wrapped_db_iter.cc b/db/arena_wrapped_db_iter.cc index 2bb0ef8d9..520588afe 100644 --- a/db/arena_wrapped_db_iter.cc +++ b/db/arena_wrapped_db_iter.cc @@ -31,16 +31,15 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name, } void ArenaWrappedDBIter::Init( - Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) { auto mem = arena_.AllocateAligned(sizeof(DBIter)); db_iter_ = - new (mem) DBIter(env, read_options, cf_options, mutable_cf_options, - cf_options.user_comparator, /* iter */ nullptr, version, + new (mem) DBIter(env, read_options, ioptions, mutable_cf_options, + ioptions.user_comparator, /* iter */ nullptr, version, sequence, true, max_sequential_skip_in_iteration, read_callback, db_impl, cfd, expose_blob_index); sv_number_ = version_number; @@ -88,16 +87,15 @@ Status ArenaWrappedDBIter::Refresh() { } ArenaWrappedDBIter* NewArenaWrappedDbIterator( - Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) { ArenaWrappedDBIter* iter = new ArenaWrappedDBIter(); - iter->Init(env, read_options, cf_options, mutable_cf_options, version, - sequence, max_sequential_skip_in_iterations, version_number, - read_callback, db_impl, cfd, expose_blob_index, allow_refresh); + iter->Init(env, read_options, ioptions, mutable_cf_options, version, sequence, + max_sequential_skip_in_iterations, version_number, read_callback, + db_impl, cfd, expose_blob_index, allow_refresh); if (db_impl != nullptr && cfd != nullptr && allow_refresh) { iter->StoreRefreshInfo(db_impl, cfd, read_callback, expose_blob_index); } diff --git a/db/arena_wrapped_db_iter.h b/db/arena_wrapped_db_iter.h index 42f65ec13..17273b201 100644 --- a/db/arena_wrapped_db_iter.h +++ b/db/arena_wrapped_db_iter.h @@ -72,7 +72,7 @@ class ArenaWrappedDBIter : public Iterator { Status Refresh() override; void Init(Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, @@ -105,8 +105,7 @@ class ArenaWrappedDBIter : public Iterator { // `db_impl` and `cfd` are used for reneweal. If left null, renewal will not // be supported. extern ArenaWrappedDBIter* NewArenaWrappedDbIterator( - Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Version* version, const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations, uint64_t version_number, ReadCallback* read_callback, diff --git a/db/blob/blob_file_builder.cc b/db/blob/blob_file_builder.cc index f27a4e25b..674466c71 100644 --- a/db/blob/blob_file_builder.cc +++ b/db/blob/blob_file_builder.cc @@ -29,7 +29,7 @@ namespace ROCKSDB_NAMESPACE { BlobFileBuilder::BlobFileBuilder( VersionSet* versions, FileSystem* fs, - const ImmutableOptions* immutable_cf_options, + const ImmutableOptions* immutable_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, const std::string& column_family_name, Env::IOPriority io_priority, @@ -39,14 +39,14 @@ BlobFileBuilder::BlobFileBuilder( std::vector* blob_file_paths, std::vector* blob_file_additions) : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs, - immutable_cf_options, mutable_cf_options, file_options, + immutable_options, mutable_cf_options, file_options, job_id, column_family_id, column_family_name, io_priority, write_hint, io_tracer, blob_callback, blob_file_paths, blob_file_additions) {} BlobFileBuilder::BlobFileBuilder( std::function file_number_generator, FileSystem* fs, - const ImmutableOptions* immutable_cf_options, + const ImmutableOptions* immutable_options, const MutableCFOptions* mutable_cf_options, const FileOptions* file_options, int job_id, uint32_t column_family_id, const std::string& column_family_name, Env::IOPriority io_priority, @@ -57,7 +57,7 @@ BlobFileBuilder::BlobFileBuilder( std::vector* blob_file_additions) : file_number_generator_(std::move(file_number_generator)), fs_(fs), - immutable_cf_options_(immutable_cf_options), + immutable_options_(immutable_options), min_blob_size_(mutable_cf_options->min_blob_size), blob_file_size_(mutable_cf_options->blob_file_size), blob_compression_type_(mutable_cf_options->blob_compression_type), @@ -75,7 +75,7 @@ BlobFileBuilder::BlobFileBuilder( blob_bytes_(0) { assert(file_number_generator_); assert(fs_); - assert(immutable_cf_options_); + assert(immutable_options_); assert(file_options_); assert(blob_file_paths_); assert(blob_file_paths_->empty()); @@ -156,10 +156,10 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() { assert(file_number_generator_); const uint64_t blob_file_number = file_number_generator_(); - assert(immutable_cf_options_); - assert(!immutable_cf_options_->cf_paths.empty()); - std::string blob_file_path = BlobFileName( - immutable_cf_options_->cf_paths.front().path, blob_file_number); + assert(immutable_options_); + assert(!immutable_options_->cf_paths.empty()); + std::string blob_file_path = + BlobFileName(immutable_options_->cf_paths.front().path, blob_file_number); std::unique_ptr file; @@ -184,20 +184,20 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() { assert(file); file->SetIOPriority(io_priority_); file->SetWriteLifeTimeHint(write_hint_); - FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types; - Statistics* const statistics = immutable_cf_options_->stats; + FileTypeSet tmp_set = immutable_options_->checksum_handoff_file_types; + Statistics* const statistics = immutable_options_->stats; std::unique_ptr file_writer(new WritableFileWriter( std::move(file), blob_file_paths_->back(), *file_options_, - immutable_cf_options_->clock, io_tracer_, statistics, - immutable_cf_options_->listeners, - immutable_cf_options_->file_checksum_gen_factory.get(), + immutable_options_->clock, io_tracer_, statistics, + immutable_options_->listeners, + immutable_options_->file_checksum_gen_factory.get(), tmp_set.Contains(FileType::kBlobFile))); constexpr bool do_flush = false; std::unique_ptr blob_log_writer(new BlobLogWriter( - std::move(file_writer), immutable_cf_options_->clock, statistics, - blob_file_number, immutable_cf_options_->use_fsync, do_flush)); + std::move(file_writer), immutable_options_->clock, statistics, + blob_file_number, immutable_options_->use_fsync, do_flush)); constexpr bool has_ttl = false; constexpr ExpirationRange expiration_range; @@ -300,8 +300,8 @@ Status BlobFileBuilder::CloseBlobFile() { std::move(checksum_method), std::move(checksum_value)); - assert(immutable_cf_options_); - ROCKS_LOG_INFO(immutable_cf_options_->logger, + assert(immutable_options_); + ROCKS_LOG_INFO(immutable_options_->logger, "[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64 " total blobs, %" PRIu64 " total bytes", column_family_name_.c_str(), job_id_, blob_file_number, diff --git a/db/blob/blob_file_builder.h b/db/blob/blob_file_builder.h index fc00097da..0929b6a77 100644 --- a/db/blob/blob_file_builder.h +++ b/db/blob/blob_file_builder.h @@ -77,7 +77,7 @@ class BlobFileBuilder { std::function file_number_generator_; FileSystem* fs_; - const ImmutableOptions* immutable_cf_options_; + const ImmutableOptions* immutable_options_; uint64_t min_blob_size_; uint64_t blob_file_size_; CompressionType blob_compression_type_; diff --git a/db/blob/blob_file_builder_test.cc b/db/blob/blob_file_builder_test.cc index d478e6663..08cfac007 100644 --- a/db/blob/blob_file_builder_test.cc +++ b/db/blob/blob_file_builder_test.cc @@ -129,7 +129,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) { options.enable_blob_files = true; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -141,12 +141,11 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); std::vector> expected_key_value_pairs( number_of_blobs); @@ -178,9 +177,9 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) { const std::string& blob_file_path = blob_file_paths[0]; - ASSERT_EQ(blob_file_path, - BlobFileName(immutable_cf_options.cf_paths.front().path, - blob_file_number)); + ASSERT_EQ( + blob_file_path, + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); ASSERT_EQ(blob_file_additions.size(), 1); @@ -214,7 +213,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) { options.blob_file_size = value_size; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -226,12 +225,11 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); std::vector> expected_key_value_pairs( number_of_blobs); @@ -264,7 +262,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) { const uint64_t blob_file_number = i + 2; ASSERT_EQ(blob_file_paths[i], - BlobFileName(immutable_cf_options.cf_paths.front().path, + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); const auto& blob_file_addition = blob_file_additions[i]; @@ -301,7 +299,7 @@ TEST_F(BlobFileBuilderTest, InlinedValues) { options.min_blob_size = 1024; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -313,12 +311,11 @@ TEST_F(BlobFileBuilderTest, InlinedValues) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); for (size_t i = 0; i < number_of_blobs; ++i) { const std::string key = std::to_string(i); @@ -355,7 +352,7 @@ TEST_F(BlobFileBuilderTest, Compression) { options.blob_compression_type = kSnappyCompression; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -367,12 +364,11 @@ TEST_F(BlobFileBuilderTest, Compression) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); const std::string key("1"); const std::string uncompressed_value(value_size, 'x'); @@ -391,9 +387,9 @@ TEST_F(BlobFileBuilderTest, Compression) { const std::string& blob_file_path = blob_file_paths[0]; - ASSERT_EQ(blob_file_path, - BlobFileName(immutable_cf_options.cf_paths.front().path, - blob_file_number)); + ASSERT_EQ( + blob_file_path, + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); ASSERT_EQ(blob_file_additions.size(), 1); @@ -438,7 +434,7 @@ TEST_F(BlobFileBuilderTest, CompressionError) { options.enable_blob_files = true; options.blob_compression_type = kSnappyCompression; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -450,12 +446,11 @@ TEST_F(BlobFileBuilderTest, CompressionError) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue", [](void* arg) { @@ -477,9 +472,9 @@ TEST_F(BlobFileBuilderTest, CompressionError) { constexpr uint64_t blob_file_number = 2; ASSERT_EQ(blob_file_paths.size(), 1); - ASSERT_EQ(blob_file_paths[0], - BlobFileName(immutable_cf_options.cf_paths.front().path, - blob_file_number)); + ASSERT_EQ( + blob_file_paths[0], + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); ASSERT_TRUE(blob_file_additions.empty()); } @@ -517,7 +512,7 @@ TEST_F(BlobFileBuilderTest, Checksum) { std::make_shared(); options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -529,12 +524,11 @@ TEST_F(BlobFileBuilderTest, Checksum) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); const std::string key("1"); const std::string value("deadbeef"); @@ -553,9 +547,9 @@ TEST_F(BlobFileBuilderTest, Checksum) { const std::string& blob_file_path = blob_file_paths[0]; - ASSERT_EQ(blob_file_path, - BlobFileName(immutable_cf_options.cf_paths.front().path, - blob_file_number)); + ASSERT_EQ( + blob_file_path, + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); ASSERT_EQ(blob_file_additions.size(), 1); @@ -614,7 +608,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) { options.blob_file_size = value_size; options.env = &mock_env_; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); MutableCFOptions mutable_cf_options(options); constexpr int job_id = 1; @@ -626,12 +620,11 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) { std::vector blob_file_paths; std::vector blob_file_additions; - BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options, - &mutable_cf_options, &file_options_, job_id, - column_family_id, column_family_name, io_priority, - write_hint, nullptr /*IOTracer*/, - nullptr /*BlobFileCompletionCallback*/, - &blob_file_paths, &blob_file_additions); + BlobFileBuilder builder( + TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options, + &file_options_, job_id, column_family_id, column_family_name, io_priority, + write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/, + &blob_file_paths, &blob_file_additions); SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) { Status* const s = static_cast(arg); @@ -658,7 +651,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) { ASSERT_EQ(blob_file_paths.size(), 1); ASSERT_EQ(blob_file_paths[0], - BlobFileName(immutable_cf_options.cf_paths.front().path, + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number)); } diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc index 0d1b73487..1a6cdf688 100644 --- a/db/blob/blob_file_cache.cc +++ b/db/blob/blob_file_cache.cc @@ -26,13 +26,13 @@ BlobFileCache::BlobFileCache(Cache* cache, const std::shared_ptr& io_tracer) : cache_(cache), mutex_(kNumberOfMutexStripes, kGetSliceNPHash64UnseededFnPtr), - immutable_cf_options_(immutable_options), + immutable_options_(immutable_options), file_options_(file_options), column_family_id_(column_family_id), blob_file_read_hist_(blob_file_read_hist), io_tracer_(io_tracer) { assert(cache_); - assert(immutable_cf_options_); + assert(immutable_options_); assert(file_options_); } @@ -63,8 +63,8 @@ Status BlobFileCache::GetBlobFileReader( return Status::OK(); } - assert(immutable_cf_options_); - Statistics* const statistics = immutable_cf_options_->stats; + assert(immutable_options_); + Statistics* const statistics = immutable_options_->stats; RecordTick(statistics, NO_FILE_OPENS); @@ -73,7 +73,7 @@ Status BlobFileCache::GetBlobFileReader( { assert(file_options_); const Status s = BlobFileReader::Create( - *immutable_cf_options_, *file_options_, column_family_id_, + *immutable_options_, *file_options_, column_family_id_, blob_file_read_hist_, blob_file_number, io_tracer_, &reader); if (!s.ok()) { RecordTick(statistics, NO_FILE_ERRORS); diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h index 599bdaded..8eec05f18 100644 --- a/db/blob/blob_file_cache.h +++ b/db/blob/blob_file_cache.h @@ -40,7 +40,7 @@ class BlobFileCache { // Note: mutex_ below is used to guard against multiple threads racing to open // the same file. Striped mutex_; - const ImmutableOptions* immutable_cf_options_; + const ImmutableOptions* immutable_options_; const FileOptions* file_options_; uint32_t column_family_id_; HistogramImpl* blob_file_read_hist_; diff --git a/db/blob/blob_file_cache_test.cc b/db/blob/blob_file_cache_test.cc index 0dc822243..bef2d6202 100644 --- a/db/blob/blob_file_cache_test.cc +++ b/db/blob/blob_file_cache_test.cc @@ -29,28 +29,27 @@ namespace { // Creates a test blob file with a single blob in it. void WriteBlobFile(uint32_t column_family_id, - const ImmutableOptions& immutable_cf_options, + const ImmutableOptions& immutable_options, uint64_t blob_file_number) { - assert(!immutable_cf_options.cf_paths.empty()); + assert(!immutable_options.cf_paths.empty()); - const std::string blob_file_path = BlobFileName( - immutable_cf_options.cf_paths.front().path, blob_file_number); + const std::string blob_file_path = + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, - &file, FileOptions())); + ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file, + FileOptions())); - std::unique_ptr file_writer( - new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), - immutable_cf_options.clock)); + std::unique_ptr file_writer(new WritableFileWriter( + std::move(file), blob_file_path, FileOptions(), immutable_options.clock)); constexpr Statistics* statistics = nullptr; constexpr bool use_fsync = false; constexpr bool do_flush = false; - BlobLogWriter blob_log_writer(std::move(file_writer), - immutable_cf_options.clock, statistics, - blob_file_number, use_fsync, do_flush); + BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock, + statistics, blob_file_number, use_fsync, + do_flush); constexpr bool has_ttl = false; constexpr ExpirationRange expiration_range; @@ -100,10 +99,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint64_t blob_file_number = 123; - WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); + WriteBlobFile(column_family_id, immutable_options, blob_file_number); constexpr size_t capacity = 10; std::shared_ptr backing_cache = NewLRUCache(capacity); @@ -111,7 +110,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) { FileOptions file_options; constexpr HistogramImpl* blob_file_read_hist = nullptr; - BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, + BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options, &file_options, column_family_id, blob_file_read_hist, nullptr /*IOTracer*/); @@ -145,10 +144,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint64_t blob_file_number = 123; - WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); + WriteBlobFile(column_family_id, immutable_options, blob_file_number); constexpr size_t capacity = 10; std::shared_ptr backing_cache = NewLRUCache(capacity); @@ -156,7 +155,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) { FileOptions file_options; constexpr HistogramImpl* blob_file_read_hist = nullptr; - BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, + BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options, &file_options, column_family_id, blob_file_read_hist, nullptr /*IOTracer*/); @@ -199,12 +198,12 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_IOError) { constexpr size_t capacity = 10; std::shared_ptr backing_cache = NewLRUCache(capacity); - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); FileOptions file_options; constexpr uint32_t column_family_id = 1; constexpr HistogramImpl* blob_file_read_hist = nullptr; - BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, + BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options, &file_options, column_family_id, blob_file_read_hist, nullptr /*IOTracer*/); @@ -231,10 +230,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) { options.enable_blob_files = true; constexpr uint32_t column_family_id = 1; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint64_t blob_file_number = 123; - WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number); + WriteBlobFile(column_family_id, immutable_options, blob_file_number); constexpr size_t capacity = 0; constexpr int num_shard_bits = -1; // determined automatically @@ -245,7 +244,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) { FileOptions file_options; constexpr HistogramImpl* blob_file_read_hist = nullptr; - BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options, + BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options, &file_options, column_family_id, blob_file_read_hist, nullptr /*IOTracer*/); diff --git a/db/blob/blob_file_reader.cc b/db/blob/blob_file_reader.cc index 9fff38340..1b4b82150 100644 --- a/db/blob/blob_file_reader.cc +++ b/db/blob/blob_file_reader.cc @@ -21,10 +21,9 @@ namespace ROCKSDB_NAMESPACE { Status BlobFileReader::Create( - const ImmutableOptions& immutable_cf_options, - const FileOptions& file_options, uint32_t column_family_id, - HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, - const std::shared_ptr& io_tracer, + const ImmutableOptions& immutable_options, const FileOptions& file_options, + uint32_t column_family_id, HistogramImpl* blob_file_read_hist, + uint64_t blob_file_number, const std::shared_ptr& io_tracer, std::unique_ptr* blob_file_reader) { assert(blob_file_reader); assert(!*blob_file_reader); @@ -34,7 +33,7 @@ Status BlobFileReader::Create( { const Status s = - OpenFile(immutable_cf_options, file_options, blob_file_read_hist, + OpenFile(immutable_options, file_options, blob_file_read_hist, blob_file_number, io_tracer, &file_size, &file_reader); if (!s.ok()) { return s; @@ -67,20 +66,20 @@ Status BlobFileReader::Create( } Status BlobFileReader::OpenFile( - const ImmutableOptions& immutable_cf_options, const FileOptions& file_opts, + const ImmutableOptions& immutable_options, const FileOptions& file_opts, HistogramImpl* blob_file_read_hist, uint64_t blob_file_number, const std::shared_ptr& io_tracer, uint64_t* file_size, std::unique_ptr* file_reader) { assert(file_size); assert(file_reader); - const auto& cf_paths = immutable_cf_options.cf_paths; + const auto& cf_paths = immutable_options.cf_paths; assert(!cf_paths.empty()); const std::string blob_file_path = BlobFileName(cf_paths.front().path, blob_file_number); - FileSystem* const fs = immutable_cf_options.fs.get(); + FileSystem* const fs = immutable_options.fs.get(); assert(fs); constexpr IODebugContext* dbg = nullptr; @@ -113,15 +112,15 @@ Status BlobFileReader::OpenFile( assert(file); - if (immutable_cf_options.advise_random_on_open) { + if (immutable_options.advise_random_on_open) { file->Hint(FSRandomAccessFile::kRandom); } file_reader->reset(new RandomAccessFileReader( - std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer, - immutable_cf_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS, - blob_file_read_hist, immutable_cf_options.rate_limiter.get(), - immutable_cf_options.listeners)); + std::move(file), blob_file_path, immutable_options.clock, io_tracer, + immutable_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS, + blob_file_read_hist, immutable_options.rate_limiter.get(), + immutable_options.listeners)); return Status::OK(); } diff --git a/db/blob/blob_file_reader_test.cc b/db/blob/blob_file_reader_test.cc index efa3c1439..e08a4bab8 100644 --- a/db/blob/blob_file_reader_test.cc +++ b/db/blob/blob_file_reader_test.cc @@ -30,35 +30,34 @@ namespace { // Creates a test blob file with a single blob in it. Note: this method // makes it possible to test various corner cases by allowing the caller // to specify the contents of various blob file header/footer fields. -void WriteBlobFile(const ImmutableOptions& immutable_cf_options, +void WriteBlobFile(const ImmutableOptions& immutable_options, uint32_t column_family_id, bool has_ttl, const ExpirationRange& expiration_range_header, const ExpirationRange& expiration_range_footer, uint64_t blob_file_number, const Slice& key, const Slice& blob, CompressionType compression_type, uint64_t* blob_offset, uint64_t* blob_size) { - assert(!immutable_cf_options.cf_paths.empty()); + assert(!immutable_options.cf_paths.empty()); assert(blob_offset); assert(blob_size); - const std::string blob_file_path = BlobFileName( - immutable_cf_options.cf_paths.front().path, blob_file_number); + const std::string blob_file_path = + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, - &file, FileOptions())); + ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file, + FileOptions())); - std::unique_ptr file_writer( - new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), - immutable_cf_options.clock)); + std::unique_ptr file_writer(new WritableFileWriter( + std::move(file), blob_file_path, FileOptions(), immutable_options.clock)); constexpr Statistics* statistics = nullptr; constexpr bool use_fsync = false; constexpr bool do_flush = false; - BlobLogWriter blob_log_writer(std::move(file_writer), - immutable_cf_options.clock, statistics, - blob_file_number, use_fsync, do_flush); + BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock, + statistics, blob_file_number, use_fsync, + do_flush); BlobLogHeader header(column_family_id, compression_type, has_ttl, expiration_range_header); @@ -122,7 +121,7 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -134,17 +133,17 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; std::unique_ptr reader; ASSERT_OK(BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader)); // Make sure the blob can be retrieved with and without checksum verification ReadOptions read_options; @@ -262,7 +261,7 @@ TEST_F(BlobFileReaderTest, Malformed) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr uint64_t blob_file_number = 1; @@ -271,23 +270,23 @@ TEST_F(BlobFileReaderTest, Malformed) { constexpr bool has_ttl = false; constexpr ExpirationRange expiration_range; - const std::string blob_file_path = BlobFileName( - immutable_cf_options.cf_paths.front().path, blob_file_number); + const std::string blob_file_path = + BlobFileName(immutable_options.cf_paths.front().path, blob_file_number); std::unique_ptr file; - ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path, - &file, FileOptions())); + ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file, + FileOptions())); std::unique_ptr file_writer( new WritableFileWriter(std::move(file), blob_file_path, FileOptions(), - immutable_cf_options.clock)); + immutable_options.clock)); constexpr Statistics* statistics = nullptr; constexpr bool use_fsync = false; constexpr bool do_flush = false; BlobLogWriter blob_log_writer(std::move(file_writer), - immutable_cf_options.clock, statistics, + immutable_options.clock, statistics, blob_file_number, use_fsync, do_flush); BlobLogHeader header(column_family_id, kNoCompression, has_ttl, @@ -300,7 +299,7 @@ TEST_F(BlobFileReaderTest, Malformed) { std::unique_ptr reader; - ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), + ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(), column_family_id, blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader) @@ -314,7 +313,7 @@ TEST_F(BlobFileReaderTest, TTL) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = true; @@ -326,15 +325,15 @@ TEST_F(BlobFileReaderTest, TTL) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; std::unique_ptr reader; - ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), + ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(), column_family_id, blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader) @@ -350,7 +349,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -364,7 +363,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range_header, expiration_range_footer, blob_file_number, key, blob, kNoCompression, &blob_offset, &blob_size); @@ -373,7 +372,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) { std::unique_ptr reader; - ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), + ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(), column_family_id, blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader) @@ -389,7 +388,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -403,7 +402,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range_header, expiration_range_footer, blob_file_number, key, blob, kNoCompression, &blob_offset, &blob_size); @@ -412,7 +411,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) { std::unique_ptr reader; - ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), + ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(), column_family_id, blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader) @@ -428,7 +427,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -440,9 +439,9 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; @@ -450,7 +449,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) { constexpr uint32_t incorrect_column_family_id = 2; - ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(), + ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(), incorrect_column_family_id, blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader) @@ -464,7 +463,7 @@ TEST_F(BlobFileReaderTest, BlobCRCError) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -476,17 +475,17 @@ TEST_F(BlobFileReaderTest, BlobCRCError) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; std::unique_ptr reader; ASSERT_OK(BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader)); SyncPoint::GetInstance()->SetCallBack( "BlobFileReader::VerifyBlob:CheckBlobCRC", [](void* arg) { @@ -522,7 +521,7 @@ TEST_F(BlobFileReaderTest, Compression) { test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -534,8 +533,8 @@ TEST_F(BlobFileReaderTest, Compression) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kSnappyCompression, &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; @@ -543,8 +542,8 @@ TEST_F(BlobFileReaderTest, Compression) { std::unique_ptr reader; ASSERT_OK(BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader)); // Make sure the blob can be retrieved with and without checksum verification ReadOptions read_options; @@ -590,7 +589,7 @@ TEST_F(BlobFileReaderTest, UncompressionError) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -602,8 +601,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kSnappyCompression, &blob_offset, &blob_size); constexpr HistogramImpl* blob_file_read_hist = nullptr; @@ -611,8 +610,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) { std::unique_ptr reader; ASSERT_OK(BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader)); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader)); SyncPoint::GetInstance()->SetCallBack( "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", [](void* arg) { @@ -671,7 +670,7 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -683,9 +682,9 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) { fault_injection_env_.SetFilesystemActive(false, @@ -698,8 +697,8 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) { std::unique_ptr reader; const Status s = BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader); const bool fail_during_create = (sync_point_ != "BlobFileReader::GetBlob:ReadFromFile"); @@ -749,7 +748,7 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) { 0); options.enable_blob_files = true; - ImmutableOptions immutable_cf_options(options); + ImmutableOptions immutable_options(options); constexpr uint32_t column_family_id = 1; constexpr bool has_ttl = false; @@ -761,9 +760,9 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) { uint64_t blob_offset = 0; uint64_t blob_size = 0; - WriteBlobFile(immutable_cf_options, column_family_id, has_ttl, - expiration_range, expiration_range, blob_file_number, key, blob, - kNoCompression, &blob_offset, &blob_size); + WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range, + expiration_range, blob_file_number, key, blob, kNoCompression, + &blob_offset, &blob_size); SyncPoint::GetInstance()->SetCallBack(sync_point_, [](void* arg) { Slice* const slice = static_cast(arg); @@ -780,8 +779,8 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) { std::unique_ptr reader; const Status s = BlobFileReader::Create( - immutable_cf_options, FileOptions(), column_family_id, - blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader); + immutable_options, FileOptions(), column_family_id, blob_file_read_hist, + blob_file_number, nullptr /*IOTracer*/, &reader); const bool fail_during_create = sync_point_ != "BlobFileReader::GetBlob:TamperWithResult"; diff --git a/db/compaction/compaction.h b/db/compaction/compaction.h index ae4cd57e8..eda9bf002 100644 --- a/db/compaction/compaction.h +++ b/db/compaction/compaction.h @@ -223,9 +223,9 @@ class Compaction { // How many total levels are there? int number_levels() const { return number_levels_; } - // Return the ImmutableCFOptions that should be used throughout the compaction + // Return the ImmutableOptions that should be used throughout the compaction // procedure - const ImmutableOptions* immutable_cf_options() const { + const ImmutableOptions* immutable_options() const { return &immutable_options_; } diff --git a/db/compaction/compaction_iterator.h b/db/compaction/compaction_iterator.h index 7c459a767..65df5c444 100644 --- a/db/compaction/compaction_iterator.h +++ b/db/compaction/compaction_iterator.h @@ -104,7 +104,7 @@ class CompactionIterator { explicit RealCompaction(const Compaction* compaction) : compaction_(compaction) { assert(compaction_); - assert(compaction_->immutable_cf_options()); + assert(compaction_->immutable_options()); assert(compaction_->mutable_cf_options()); } @@ -126,11 +126,11 @@ class CompactionIterator { } bool allow_ingest_behind() const override { - return compaction_->immutable_cf_options()->allow_ingest_behind; + return compaction_->immutable_options()->allow_ingest_behind; } bool preserve_deletes() const override { - return compaction_->immutable_cf_options()->preserve_deletes; + return compaction_->immutable_options()->preserve_deletes; } bool enable_blob_garbage_collection() const override { diff --git a/db/compaction/compaction_job.cc b/db/compaction/compaction_job.cc index 38b0a3a80..a8e0bd596 100644 --- a/db/compaction/compaction_job.cc +++ b/db/compaction/compaction_job.cc @@ -553,9 +553,10 @@ void CompactionJob::GenSubcompactionBoundaries() { int base_level = v->storage_info()->base_level(); uint64_t max_output_files = static_cast(std::ceil( sum / min_file_fill_percent / - MaxFileSizeForLevel(*(c->mutable_cf_options()), out_lvl, - c->immutable_cf_options()->compaction_style, base_level, - c->immutable_cf_options()->level_compaction_dynamic_level_bytes))); + MaxFileSizeForLevel( + *(c->mutable_cf_options()), out_lvl, + c->immutable_options()->compaction_style, base_level, + c->immutable_options()->level_compaction_dynamic_level_bytes))); uint64_t subcompactions = std::min({static_cast(ranges.size()), static_cast(c->max_subcompactions()), @@ -754,7 +755,7 @@ Status CompactionJob::Run() { for (const auto& state : compact_->sub_compact_states) { for (const auto& output : state.outputs) { auto fn = - TableFileName(state.compaction->immutable_cf_options()->cf_paths, + TableFileName(state.compaction->immutable_options()->cf_paths, output.meta.fd.GetNumber(), output.meta.fd.GetPathId()); tp[fn] = output.table_properties; } @@ -1017,7 +1018,7 @@ void CompactionJob::ProcessKeyValueCompactionWithCompactionService( for (const auto& file : compaction_result.output_files) { uint64_t file_num = versions_->NewFileNumber(); auto src_file = compaction_result.output_path + "/" + file.file_name; - auto tgt_file = TableFileName(compaction->immutable_cf_options()->cf_paths, + auto tgt_file = TableFileName(compaction->immutable_options()->cf_paths, file_num, compaction->output_path_id()); s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr); if (!s.ok()) { @@ -1176,7 +1177,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) { std::unique_ptr blob_file_builder( mutable_cf_options->enable_blob_files ? new BlobFileBuilder(versions_, fs_.get(), - sub_compact->compaction->immutable_cf_options(), + sub_compact->compaction->immutable_options(), mutable_cf_options, &file_options_, job_id_, cfd->GetID(), cfd->GetName(), Env::IOPriority::IO_LOW, write_hint_, @@ -1698,7 +1699,7 @@ Status CompactionJob::FinishCompactionOutputFile( // This happens when the output level is bottom level, at the same time // the sub_compact output nothing. std::string fname = - TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths, + TableFileName(sub_compact->compaction->immutable_options()->cf_paths, meta->fd.GetNumber(), meta->fd.GetPathId()); // TODO(AR) it is not clear if there are any larger implications if @@ -1942,7 +1943,7 @@ Status CompactionJob::OpenCompactionOutputFile( writable_file->SetPreallocationBlockSize(static_cast( sub_compact->compaction->OutputFilePreallocationSize())); const auto& listeners = - sub_compact->compaction->immutable_cf_options()->listeners; + sub_compact->compaction->immutable_options()->listeners; sub_compact->outfile.reset(new WritableFileWriter( std::move(writable_file), fname, file_options_, db_options_.clock, io_tracer_, db_options_.stats, listeners, @@ -2124,7 +2125,7 @@ void CompactionJob::LogCompaction() { } std::string CompactionJob::GetTableFileName(uint64_t file_number) { - return TableFileName(compact_->compaction->immutable_cf_options()->cf_paths, + return TableFileName(compact_->compaction->immutable_options()->cf_paths, file_number, compact_->compaction->output_path_id()); } diff --git a/db/db_impl/db_impl_compaction_flush.cc b/db/db_impl/db_impl_compaction_flush.cc index ec876d91e..d583bebc1 100644 --- a/db/db_impl/db_impl_compaction_flush.cc +++ b/db/db_impl/db_impl_compaction_flush.cc @@ -1332,7 +1332,7 @@ Status DBImpl::CompactFilesImpl( if (output_file_names != nullptr) { for (const auto& newf : c->edit()->GetNewFiles()) { (*output_file_names) - .push_back(TableFileName(c->immutable_cf_options()->cf_paths, + .push_back(TableFileName(c->immutable_options()->cf_paths, newf.second.fd.GetNumber(), newf.second.fd.GetPathId())); } @@ -2957,7 +2957,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress, c->column_family_data() ->current() ->storage_info() - ->ComputeCompactionScore(*(c->immutable_cf_options()), + ->ComputeCompactionScore(*(c->immutable_options()), *(c->mutable_cf_options())); AddToCompactionQueue(cfd); ++unscheduled_compactions_; @@ -3232,7 +3232,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress, c->column_family_data() ->current() ->storage_info() - ->ComputeCompactionScore(*(c->immutable_cf_options()), + ->ComputeCompactionScore(*(c->immutable_options()), *(c->mutable_cf_options())); if (!cfd->queued_for_compaction()) { AddToCompactionQueue(cfd); @@ -3397,7 +3397,7 @@ void DBImpl::BuildCompactionJobInfo( for (const auto fmd : *c->inputs(i)) { const FileDescriptor& desc = fmd->fd; const uint64_t file_number = desc.GetNumber(); - auto fn = TableFileName(c->immutable_cf_options()->cf_paths, file_number, + auto fn = TableFileName(c->immutable_options()->cf_paths, file_number, desc.GetPathId()); compaction_job_info->input_files.push_back(fn); compaction_job_info->input_file_infos.push_back(CompactionFileInfo{ @@ -3416,7 +3416,7 @@ void DBImpl::BuildCompactionJobInfo( const FileDescriptor& desc = meta.fd; const uint64_t file_number = desc.GetNumber(); compaction_job_info->output_files.push_back(TableFileName( - c->immutable_cf_options()->cf_paths, file_number, desc.GetPathId())); + c->immutable_options()->cf_paths, file_number, desc.GetPathId())); compaction_job_info->output_file_infos.push_back(CompactionFileInfo{ newf.first, file_number, meta.oldest_blob_file_number}); } diff --git a/db/db_iter.cc b/db/db_iter.cc index 038f30053..75a196e4d 100644 --- a/db/db_iter.cc +++ b/db/db_iter.cc @@ -36,7 +36,7 @@ namespace ROCKSDB_NAMESPACE { DBIter::DBIter(Env* _env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Comparator* cmp, InternalIterator* iter, const Version* version, SequenceNumber s, bool arena_mode, @@ -45,15 +45,15 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options, ColumnFamilyData* cfd, bool expose_blob_index) : prefix_extractor_(mutable_cf_options.prefix_extractor.get()), env_(_env), - clock_(cf_options.clock), - logger_(cf_options.logger), + clock_(ioptions.clock), + logger_(ioptions.logger), user_comparator_(cmp), - merge_operator_(cf_options.merge_operator.get()), + merge_operator_(ioptions.merge_operator.get()), iter_(iter), version_(version), read_callback_(read_callback), sequence_(s), - statistics_(cf_options.stats), + statistics_(ioptions.stats), max_skip_(max_sequential_skip_in_iterations), max_skippable_internal_keys_(read_options.max_skippable_internal_keys), num_internal_keys_skipped_(0), @@ -75,7 +75,7 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options, expose_blob_index_(expose_blob_index), is_blob_(false), arena_mode_(arena_mode), - range_del_agg_(&cf_options.internal_comparator, s), + range_del_agg_(&ioptions.internal_comparator, s), db_impl_(db_impl), cfd_(cfd), start_seqnum_(read_options.iter_start_seqnum), @@ -1578,7 +1578,7 @@ void DBIter::SeekToLast() { } Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const Version* version, @@ -1587,7 +1587,7 @@ Iterator* NewDBIterator(Env* env, const ReadOptions& read_options, ReadCallback* read_callback, DBImpl* db_impl, ColumnFamilyData* cfd, bool expose_blob_index) { DBIter* db_iter = - new DBIter(env, read_options, cf_options, mutable_cf_options, + new DBIter(env, read_options, ioptions, mutable_cf_options, user_key_comparator, internal_iter, version, sequence, false, max_sequential_skip_in_iterations, read_callback, db_impl, cfd, expose_blob_index); diff --git a/db/db_iter.h b/db/db_iter.h index 9b296d08b..52bffa55d 100644 --- a/db/db_iter.h +++ b/db/db_iter.h @@ -114,7 +114,7 @@ class DBIter final : public Iterator { }; DBIter(Env* _env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Comparator* cmp, InternalIterator* iter, const Version* version, SequenceNumber s, bool arena_mode, uint64_t max_sequential_skip_in_iterations, @@ -385,8 +385,7 @@ class DBIter final : public Iterator { // "*internal_iter") that were live at the specified `sequence` number // into appropriate user keys. extern Iterator* NewDBIterator( - Env* env, const ReadOptions& read_options, - const ImmutableOptions& cf_options, + Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions, const MutableCFOptions& mutable_cf_options, const Comparator* user_key_comparator, InternalIterator* internal_iter, const Version* version, const SequenceNumber& sequence, diff --git a/db/db_iter_test.cc b/db/db_iter_test.cc index cc2a77b19..252b192fe 100644 --- a/db/db_iter_test.cc +++ b/db/db_iter_test.cc @@ -237,7 +237,7 @@ class DBIteratorTest : public testing::Test { TEST_F(DBIteratorTest, DBIteratorPrevNext) { Options options; - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { TestIterator* internal_iter = new TestIterator(BytewiseComparator()); @@ -252,7 +252,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -286,7 +286,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -314,7 +314,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -348,7 +348,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -385,7 +385,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -417,7 +417,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 7 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -456,7 +456,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -483,7 +483,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -508,7 +508,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -545,7 +545,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ro.iterate_upper_bound = &prefix; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 7 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -576,7 +576,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -621,7 +621,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -654,7 +654,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { ReadOptions ro; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -677,7 +677,7 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) { TEST_F(DBIteratorTest, DBIteratorEmpty) { Options options; - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); ReadOptions ro; @@ -686,7 +686,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -700,7 +700,7 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -757,7 +757,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -772,7 +772,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, i + 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -810,7 +810,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, i + 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -841,7 +841,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 202 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -876,7 +876,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->AddPut("c", "200"); internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, i /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -896,7 +896,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->AddPut("c", "200"); internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 200 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -934,7 +934,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, i + 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -971,7 +971,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, i + 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1004,7 +1004,7 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) { TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { Options options; - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); ReadOptions ro; @@ -1023,7 +1023,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 0; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1071,7 +1071,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1117,7 +1117,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1157,7 +1157,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1194,7 +1194,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1226,7 +1226,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1265,7 +1265,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = 2; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1304,7 +1304,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { ro.max_skippable_internal_keys = i; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1359,7 +1359,7 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) { options.max_sequential_skip_in_iterations = 1000; ro.max_skippable_internal_keys = i; std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1500,7 +1500,7 @@ TEST_F(DBIteratorTest, DBIterator5) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1515,7 +1515,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1539,7 +1539,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1563,7 +1563,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1587,7 +1587,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 3 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1611,7 +1611,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1635,7 +1635,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 5 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1659,7 +1659,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 6 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1681,7 +1681,7 @@ TEST_F(DBIteratorTest, DBIterator5) { internal_iter->AddPut("b", "val_b"); internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 10 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1698,7 +1698,7 @@ TEST_F(DBIteratorTest, DBIterator6) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1713,7 +1713,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1737,7 +1737,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 1 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1761,7 +1761,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1785,7 +1785,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 3 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1805,7 +1805,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1829,7 +1829,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 5 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1853,7 +1853,7 @@ TEST_F(DBIteratorTest, DBIterator6) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 6 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1870,7 +1870,7 @@ TEST_F(DBIteratorTest, DBIterator7) { ReadOptions ro; Options options; options.merge_operator = MergeOperators::CreateFromStringId("stringappend"); - ImmutableOptions cf_options = ImmutableOptions(options); + ImmutableOptions ioptions = ImmutableOptions(options); MutableCFOptions mutable_cf_options = MutableCFOptions(options); { @@ -1897,7 +1897,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 0 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1933,7 +1933,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 2 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -1975,7 +1975,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 4 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2017,7 +2017,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 5 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2064,7 +2064,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 6 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2112,7 +2112,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 7 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2154,7 +2154,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 9 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2202,7 +2202,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 13 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); @@ -2251,7 +2251,7 @@ TEST_F(DBIteratorTest, DBIterator7) { internal_iter->Finish(); std::unique_ptr db_iter(NewDBIterator( - env_, ro, cf_options, mutable_cf_options, BytewiseComparator(), + env_, ro, ioptions, mutable_cf_options, BytewiseComparator(), internal_iter, nullptr /* version */, 14 /* sequence */, options.max_sequential_skip_in_iterations, nullptr /* read_callback */)); diff --git a/db/job_context.h b/db/job_context.h index 841155200..cf48888e0 100644 --- a/db/job_context.h +++ b/db/job_context.h @@ -23,7 +23,7 @@ struct SuperVersion; struct SuperVersionContext { struct WriteStallNotification { WriteStallInfo write_stall_info; - const ImmutableOptions* immutable_cf_options; + const ImmutableOptions* immutable_options; }; autovector superversions_to_free; @@ -66,7 +66,7 @@ struct SuperVersionContext { notif.write_stall_info.cf_name = name; notif.write_stall_info.condition.prev = old_cond; notif.write_stall_info.condition.cur = new_cond; - notif.immutable_cf_options = ioptions; + notif.immutable_options = ioptions; write_stall_notifications.push_back(notif); #else (void)old_cond; @@ -80,7 +80,7 @@ struct SuperVersionContext { #if !defined(ROCKSDB_LITE) && !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION) // notify listeners on changed write stall conditions for (auto& notif : write_stall_notifications) { - for (auto& listener : notif.immutable_cf_options->listeners) { + for (auto& listener : notif.immutable_options->listeners) { listener->OnStallConditionsChanged(notif.write_stall_info); } } diff --git a/db/version_set.cc b/db/version_set.cc index a53817a9e..8f2d867d5 100644 --- a/db/version_set.cc +++ b/db/version_set.cc @@ -2554,7 +2554,7 @@ uint32_t GetExpiredTtlFilesCount(const ImmutableOptions& ioptions, } // anonymous namespace void VersionStorageInfo::ComputeCompactionScore( - const ImmutableOptions& immutable_cf_options, + const ImmutableOptions& immutable_options, const MutableCFOptions& mutable_cf_options) { for (int level = 0; level <= MaxInputLevel(); level++) { double score; @@ -2606,7 +2606,7 @@ void VersionStorageInfo::ComputeCompactionScore( if (mutable_cf_options.ttl > 0) { score = std::max( static_cast(GetExpiredTtlFilesCount( - immutable_cf_options, mutable_cf_options, files_[level])), + immutable_options, mutable_cf_options, files_[level])), score); } @@ -2618,7 +2618,7 @@ void VersionStorageInfo::ComputeCompactionScore( // L0 files. Take into account size as well to avoid later giant // compactions to the base level. uint64_t l0_target_size = mutable_cf_options.max_bytes_for_level_base; - if (immutable_cf_options.level_compaction_dynamic_level_bytes && + if (immutable_options.level_compaction_dynamic_level_bytes && level_multiplier_ != 0.0) { // Prevent L0 to Lbase fanout from growing larger than // `level_multiplier_`. This prevents us from getting stuck picking @@ -2666,11 +2666,11 @@ void VersionStorageInfo::ComputeCompactionScore( ComputeFilesMarkedForCompaction(); ComputeBottommostFilesMarkedForCompaction(); if (mutable_cf_options.ttl > 0) { - ComputeExpiredTtlFiles(immutable_cf_options, mutable_cf_options.ttl); + ComputeExpiredTtlFiles(immutable_options, mutable_cf_options.ttl); } if (mutable_cf_options.periodic_compaction_seconds > 0) { ComputeFilesMarkedForPeriodicCompaction( - immutable_cf_options, mutable_cf_options.periodic_compaction_seconds); + immutable_options, mutable_cf_options.periodic_compaction_seconds); } EstimateCompactionBytesNeeded(mutable_cf_options); } diff --git a/db/version_set.h b/db/version_set.h index e2351ec08..bbe872c99 100644 --- a/db/version_set.h +++ b/db/version_set.h @@ -150,7 +150,7 @@ class VersionStorageInfo { // We use compaction scores to figure out which compaction to do next // REQUIRES: db_mutex held!! // TODO find a better way to pass compaction_options_fifo. - void ComputeCompactionScore(const ImmutableOptions& immutable_cf_options, + void ComputeCompactionScore(const ImmutableOptions& immutable_options, const MutableCFOptions& mutable_cf_options); // Estimate est_comp_needed_bytes_ diff --git a/db/version_set_test.cc b/db/version_set_test.cc index bb29b0f30..75919c6ed 100644 --- a/db/version_set_test.cc +++ b/db/version_set_test.cc @@ -699,7 +699,7 @@ class VersionSetTestBase { options_(), db_options_(options_), cf_options_(options_), - immutable_cf_options_(db_options_, cf_options_), + immutable_options_(db_options_, cf_options_), mutable_cf_options_(cf_options_), table_cache_(NewLRUCache(50000, 16)), write_buffer_manager_(db_options_.db_write_buffer_size), @@ -718,9 +718,9 @@ class VersionSetTestBase { options_.env = env_; db_options_.env = env_; db_options_.fs = fs_; - immutable_cf_options_.env = env_; - immutable_cf_options_.fs = fs_; - immutable_cf_options_.clock = env_->GetSystemClock().get(); + immutable_options_.env = env_; + immutable_options_.fs = fs_; + immutable_options_.clock = env_->GetSystemClock().get(); versions_.reset( new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(), @@ -908,7 +908,7 @@ class VersionSetTestBase { Options options_; ImmutableDBOptions db_options_; ColumnFamilyOptions cf_options_; - ImmutableOptions immutable_cf_options_; + ImmutableOptions immutable_options_; MutableCFOptions mutable_cf_options_; std::shared_ptr table_cache_; WriteController write_controller_; @@ -2785,7 +2785,7 @@ class VersionSetTestMissingFiles : public VersionSetTestBase, std::unique_ptr builder(table_factory_->NewTableBuilder( TableBuilderOptions( - immutable_cf_options_, mutable_cf_options_, *internal_comparator_, + immutable_options_, mutable_cf_options_, *internal_comparator_, &int_tbl_prop_collector_factories, kNoCompression, CompressionOptions(), TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,