andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename variables in ImmutableCFOptions to avoid conflicts with ImmutableDBOptions (#8227)

Browse Source 
Summary:
Renaming ImmutableCFOptions::info_log and statistics to logger and stats.  This is stage 2 in creating an ImmutableOptions class.  It is necessary because the names match those in ImmutableOptions and have different types.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8227

Reviewed By: jay-zhuang

Differential Revision: D28000967

Pulled By: mrambacher

fbshipit-source-id: 3bf2aa04e8f1e8724d825b7deacf41080c14420b
This commit is contained in:
mrambacher 2021-04-26 12:43:02 -07:00 committed by Facebook GitHub Bot
parent c2c7d5e916
commit 0ca6d6297f
30 changed files with 137 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
db/blob/blob_file_builder.cc
View File

@ -185,7 +185,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
file->SetIOPriority(io_priority_); file->SetIOPriority(io_priority_);
file->SetWriteLifeTimeHint(write_hint_); file->SetWriteLifeTimeHint(write_hint_);
FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types; FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types;
Statistics* const statistics = immutable_cf_options_->statistics; Statistics* const statistics = immutable_cf_options_->stats;
std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter( std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
std::move(file), blob_file_paths_->back(), *file_options_, std::move(file), blob_file_paths_->back(), *file_options_,
immutable_cf_options_->clock, io_tracer_, statistics, immutable_cf_options_->clock, io_tracer_, statistics,
@ -301,7 +301,7 @@ Status BlobFileBuilder::CloseBlobFile() {
std::move(checksum_value)); std::move(checksum_value));
assert(immutable_cf_options_); assert(immutable_cf_options_);
ROCKS_LOG_INFO(immutable_cf_options_->info_log, ROCKS_LOG_INFO(immutable_cf_options_->logger,
"[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64 "[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64
" total blobs, %" PRIu64 " total bytes", " total blobs, %" PRIu64 " total bytes",
column_family_name_.c_str(), job_id_, blob_file_number, column_family_name_.c_str(), job_id_, blob_file_number,

2
db/blob/blob_file_cache.cc
View File

@ -64,7 +64,7 @@ Status BlobFileCache::GetBlobFileReader(
} }
assert(immutable_cf_options_); assert(immutable_cf_options_);
Statistics* const statistics = immutable_cf_options_->statistics; Statistics* const statistics = immutable_cf_options_->stats;
RecordTick(statistics, NO_FILE_OPENS); RecordTick(statistics, NO_FILE_OPENS);

2
db/blob/blob_file_reader.cc
View File

@ -119,7 +119,7 @@ Status BlobFileReader::OpenFile(
file_reader->reset(new RandomAccessFileReader( file_reader->reset(new RandomAccessFileReader(
std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer, std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer,
immutable_cf_options.statistics, BLOB_DB_BLOB_FILE_READ_MICROS, immutable_cf_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS,
blob_file_read_hist, immutable_cf_options.rate_limiter.get(), blob_file_read_hist, immutable_cf_options.rate_limiter.get(),
immutable_cf_options.listeners)); immutable_cf_options.listeners));

8
db/builder.cc
View File

@ -155,7 +155,7 @@ Status BuildTable(
file->SetWriteLifeTimeHint(write_hint); file->SetWriteLifeTimeHint(write_hint);
file_writer.reset(new WritableFileWriter( file_writer.reset(new WritableFileWriter(
std::move(file), fname, file_options, ioptions.clock, io_tracer, std::move(file), fname, file_options, ioptions.clock, io_tracer,
ioptions.statistics, ioptions.listeners, ioptions.stats, ioptions.listeners,
ioptions.file_checksum_gen_factory.get(), ioptions.file_checksum_gen_factory.get(),
tmp_set.Contains(FileType::kTableFile))); tmp_set.Contains(FileType::kTableFile)));
@ -168,7 +168,7 @@ Status BuildTable(
} }
MergeHelper merge(env, internal_comparator.user_comparator(), MergeHelper merge(env, internal_comparator.user_comparator(),
ioptions.merge_operator.get(), nullptr, ioptions.info_log, ioptions.merge_operator.get(), nullptr, ioptions.logger,
true /* internal key corruption is not ok */, true /* internal key corruption is not ok */,
snapshots.empty() ? 0 : snapshots.back(), snapshots.empty() ? 0 : snapshots.back(),
snapshot_checker); snapshot_checker);
@ -185,7 +185,7 @@ Status BuildTable(
CompactionIterator c_iter( CompactionIterator c_iter(
iter, internal_comparator.user_comparator(), &merge, kMaxSequenceNumber, iter, internal_comparator.user_comparator(), &merge, kMaxSequenceNumber,
&snapshots, earliest_write_conflict_snapshot, snapshot_checker, env, &snapshots, earliest_write_conflict_snapshot, snapshot_checker, env,
ShouldReportDetailedTime(env, ioptions.statistics), ShouldReportDetailedTime(env, ioptions.stats),
true /* internal key corruption is not ok */, range_del_agg.get(), true /* internal key corruption is not ok */, range_del_agg.get(),
blob_file_builder.get(), ioptions.allow_data_in_errors, blob_file_builder.get(), ioptions.allow_data_in_errors,
/*compaction=*/nullptr, /*compaction=*/nullptr,
@ -257,7 +257,7 @@ Status BuildTable(
// Finish and check for file errors // Finish and check for file errors
TEST_SYNC_POINT("BuildTable:BeforeSyncTable"); TEST_SYNC_POINT("BuildTable:BeforeSyncTable");
if (s.ok() && !empty) { if (s.ok() && !empty) {
StopWatch sw(ioptions.clock, ioptions.statistics, TABLE_SYNC_MICROS); StopWatch sw(ioptions.clock, ioptions.stats, TABLE_SYNC_MICROS);
*io_status = file_writer->Sync(ioptions.use_fsync); *io_status = file_writer->Sync(ioptions.use_fsync);
} }
TEST_SYNC_POINT("BuildTable:BeforeCloseTableFile"); TEST_SYNC_POINT("BuildTable:BeforeCloseTableFile");

40
db/column_family.cc
View File

@ -283,7 +283,7 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
} }
if (result.level0_file_num_compaction_trigger == 0) { if (result.level0_file_num_compaction_trigger == 0) {
ROCKS_LOG_WARN(db_options.info_log.get(), ROCKS_LOG_WARN(db_options.logger,
"level0_file_num_compaction_trigger cannot be 0"); "level0_file_num_compaction_trigger cannot be 0");
result.level0_file_num_compaction_trigger = 1; result.level0_file_num_compaction_trigger = 1;
} }
@ -292,7 +292,7 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
result.level0_slowdown_writes_trigger || result.level0_slowdown_writes_trigger ||
result.level0_slowdown_writes_trigger < result.level0_slowdown_writes_trigger <
result.level0_file_num_compaction_trigger) { result.level0_file_num_compaction_trigger) {
ROCKS_LOG_WARN(db_options.info_log.get(), ROCKS_LOG_WARN(db_options.logger,
"This condition must be satisfied: " "This condition must be satisfied: "
"level0_stop_writes_trigger(%d) >= " "level0_stop_writes_trigger(%d) >= "
"level0_slowdown_writes_trigger(%d) >= " "level0_slowdown_writes_trigger(%d) >= "
@ -309,7 +309,7 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
result.level0_slowdown_writes_trigger) { result.level0_slowdown_writes_trigger) {
result.level0_stop_writes_trigger = result.level0_slowdown_writes_trigger; result.level0_stop_writes_trigger = result.level0_slowdown_writes_trigger;
} }
ROCKS_LOG_WARN(db_options.info_log.get(), ROCKS_LOG_WARN(db_options.logger,
"Adjust the value to " "Adjust the value to "
"level0_stop_writes_trigger(%d)" "level0_stop_writes_trigger(%d)"
"level0_slowdown_writes_trigger(%d)" "level0_slowdown_writes_trigger(%d)"
@ -545,7 +545,7 @@ ColumnFamilyData::ColumnFamilyData(
db_paths_registered_ = true; db_paths_registered_ = true;
} else { } else {
ROCKS_LOG_ERROR( ROCKS_LOG_ERROR(
ioptions_.info_log, ioptions_.logger,
"Failed to register data paths of column family (id: %d, name: %s)", "Failed to register data paths of column family (id: %d, name: %s)",
id_, name_.c_str()); id_, name_.c_str());
} }
@ -578,13 +578,13 @@ ColumnFamilyData::ColumnFamilyData(
} else if (ioptions_.compaction_style == kCompactionStyleNone) { } else if (ioptions_.compaction_style == kCompactionStyleNone) {
compaction_picker_.reset(new NullCompactionPicker( compaction_picker_.reset(new NullCompactionPicker(
ioptions_, &internal_comparator_)); ioptions_, &internal_comparator_));
ROCKS_LOG_WARN(ioptions_.info_log, ROCKS_LOG_WARN(ioptions_.logger,
"Column family %s does not use any background compaction. " "Column family %s does not use any background compaction. "
"Compactions can only be done via CompactFiles\n", "Compactions can only be done via CompactFiles\n",
GetName().c_str()); GetName().c_str());
#endif // !ROCKSDB_LITE #endif // !ROCKSDB_LITE
} else { } else {
ROCKS_LOG_ERROR(ioptions_.info_log, ROCKS_LOG_ERROR(ioptions_.logger,
"Unable to recognize the specified compaction style %d. " "Unable to recognize the specified compaction style %d. "
"Column family %s will use kCompactionStyleLevel.\n", "Column family %s will use kCompactionStyleLevel.\n",
ioptions_.compaction_style, GetName().c_str()); ioptions_.compaction_style, GetName().c_str());
@ -593,12 +593,12 @@ ColumnFamilyData::ColumnFamilyData(
} }
if (column_family_set_->NumberOfColumnFamilies() < 10) { if (column_family_set_->NumberOfColumnFamilies() < 10) {
ROCKS_LOG_INFO(ioptions_.info_log, ROCKS_LOG_INFO(ioptions_.logger,
"--------------- Options for column family [%s]:\n", "--------------- Options for column family [%s]:\n",
name.c_str()); name.c_str());
initial_cf_options_.Dump(ioptions_.info_log); initial_cf_options_.Dump(ioptions_.logger);
} else { } else {
ROCKS_LOG_INFO(ioptions_.info_log, "\t(skipping printing options)\n"); ROCKS_LOG_INFO(ioptions_.logger, "\t(skipping printing options)\n");
} }
} }
@ -654,7 +654,7 @@ ColumnFamilyData::~ColumnFamilyData() {
Status s = ioptions_.env->UnregisterDbPaths(GetDbPaths()); Status s = ioptions_.env->UnregisterDbPaths(GetDbPaths());
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_ERROR( ROCKS_LOG_ERROR(
ioptions_.info_log, ioptions_.logger,
"Failed to unregister data paths of column family (id: %d, name: %s)", "Failed to unregister data paths of column family (id: %d, name: %s)",
id_, name_.c_str()); id_, name_.c_str());
} }
@ -893,7 +893,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
write_controller_token_ = write_controller->GetStopToken(); write_controller_token_ = write_controller->GetStopToken();
internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_STOPS, 1); internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_STOPS, 1);
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
ioptions_.info_log, ioptions_.logger,
"[%s] Stopping writes because we have %d immutable memtables " "[%s] Stopping writes because we have %d immutable memtables "
"(waiting for flush), max_write_buffer_number is set to %d", "(waiting for flush), max_write_buffer_number is set to %d",
name_.c_str(), imm()->NumNotFlushed(), name_.c_str(), imm()->NumNotFlushed(),
@ -906,7 +906,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
internal_stats_->AddCFStats( internal_stats_->AddCFStats(
InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_STOPS, 1); InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_STOPS, 1);
} }
ROCKS_LOG_WARN(ioptions_.info_log, ROCKS_LOG_WARN(ioptions_.logger,
"[%s] Stopping writes because we have %d level-0 files", "[%s] Stopping writes because we have %d level-0 files",
name_.c_str(), vstorage->l0_delay_trigger_count()); name_.c_str(), vstorage->l0_delay_trigger_count());
} else if (write_stall_condition == WriteStallCondition::kStopped && } else if (write_stall_condition == WriteStallCondition::kStopped &&
@ -915,7 +915,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
internal_stats_->AddCFStats( internal_stats_->AddCFStats(
InternalStats::PENDING_COMPACTION_BYTES_LIMIT_STOPS, 1); InternalStats::PENDING_COMPACTION_BYTES_LIMIT_STOPS, 1);
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
ioptions_.info_log, ioptions_.logger,
"[%s] Stopping writes because of estimated pending compaction " "[%s] Stopping writes because of estimated pending compaction "
"bytes %" PRIu64, "bytes %" PRIu64,
name_.c_str(), compaction_needed_bytes); name_.c_str(), compaction_needed_bytes);
@ -927,7 +927,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
mutable_cf_options.disable_auto_compactions); mutable_cf_options.disable_auto_compactions);
internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_SLOWDOWNS, 1); internal_stats_->AddCFStats(InternalStats::MEMTABLE_LIMIT_SLOWDOWNS, 1);
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
ioptions_.info_log, ioptions_.logger,
"[%s] Stalling writes because we have %d immutable memtables " "[%s] Stalling writes because we have %d immutable memtables "
"(waiting for flush), max_write_buffer_number is set to %d " "(waiting for flush), max_write_buffer_number is set to %d "
"rate %" PRIu64, "rate %" PRIu64,
@ -949,7 +949,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
internal_stats_->AddCFStats( internal_stats_->AddCFStats(
InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS, 1); InternalStats::LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS, 1);
} }
ROCKS_LOG_WARN(ioptions_.info_log, ROCKS_LOG_WARN(ioptions_.logger,
"[%s] Stalling writes because we have %d level-0 files " "[%s] Stalling writes because we have %d level-0 files "
"rate %" PRIu64, "rate %" PRIu64,
name_.c_str(), vstorage->l0_delay_trigger_count(), name_.c_str(), vstorage->l0_delay_trigger_count(),
@ -974,7 +974,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
internal_stats_->AddCFStats( internal_stats_->AddCFStats(
InternalStats::PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS, 1); InternalStats::PENDING_COMPACTION_BYTES_LIMIT_SLOWDOWNS, 1);
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
ioptions_.info_log, ioptions_.logger,
"[%s] Stalling writes because of estimated pending compaction " "[%s] Stalling writes because of estimated pending compaction "
"bytes %" PRIu64 " rate %" PRIu64, "bytes %" PRIu64 " rate %" PRIu64,
name_.c_str(), vstorage->estimated_compaction_needed_bytes(), name_.c_str(), vstorage->estimated_compaction_needed_bytes(),
@ -988,7 +988,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
write_controller_token_ = write_controller_token_ =
write_controller->GetCompactionPressureToken(); write_controller->GetCompactionPressureToken();
ROCKS_LOG_INFO( ROCKS_LOG_INFO(
ioptions_.info_log, ioptions_.logger,
"[%s] Increasing compaction threads because we have %d level-0 " "[%s] Increasing compaction threads because we have %d level-0 "
"files ", "files ",
name_.c_str(), vstorage->l0_delay_trigger_count()); name_.c_str(), vstorage->l0_delay_trigger_count());
@ -1002,7 +1002,7 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
write_controller->GetCompactionPressureToken(); write_controller->GetCompactionPressureToken();
if (mutable_cf_options.soft_pending_compaction_bytes_limit > 0) { if (mutable_cf_options.soft_pending_compaction_bytes_limit > 0) {
ROCKS_LOG_INFO( ROCKS_LOG_INFO(
ioptions_.info_log, ioptions_.logger,
"[%s] Increasing compaction threads because of estimated pending " "[%s] Increasing compaction threads because of estimated pending "
"compaction " "compaction "
"bytes %" PRIu64, "bytes %" PRIu64,
@ -1203,11 +1203,11 @@ SuperVersion* ColumnFamilyData::GetThreadLocalSuperVersion(DBImpl* db) {
SuperVersion* sv = static_cast<SuperVersion*>(ptr); SuperVersion* sv = static_cast<SuperVersion*>(ptr);
if (sv == SuperVersion::kSVObsolete || if (sv == SuperVersion::kSVObsolete ||
sv->version_number != super_version_number_.load()) { sv->version_number != super_version_number_.load()) {
RecordTick(ioptions_.statistics, NUMBER_SUPERVERSION_ACQUIRES); RecordTick(ioptions_.stats, NUMBER_SUPERVERSION_ACQUIRES);
SuperVersion* sv_to_delete = nullptr; SuperVersion* sv_to_delete = nullptr;
if (sv && sv->Unref()) { if (sv && sv->Unref()) {
RecordTick(ioptions_.statistics, NUMBER_SUPERVERSION_CLEANUPS); RecordTick(ioptions_.stats, NUMBER_SUPERVERSION_CLEANUPS);
db->mutex()->Lock(); db->mutex()->Lock();
// NOTE: underlying resources held by superversion (sst files) might // NOTE: underlying resources held by superversion (sst files) might
// not be released until the next background job. // not be released until the next background job.

2
db/compaction/compaction_picker.cc
View File

@ -530,7 +530,7 @@ bool CompactionPicker::SetupOtherInputs(
} }
} }
if (expand_inputs) { if (expand_inputs) {
ROCKS_LOG_INFO(ioptions_.info_log, ROCKS_LOG_INFO(ioptions_.logger,
"[%s] Expanding@%d %" ROCKSDB_PRIszt "+%" ROCKSDB_PRIszt "[%s] Expanding@%d %" ROCKSDB_PRIszt "+%" ROCKSDB_PRIszt
"(%" PRIu64 "+%" PRIu64 " bytes) to %" ROCKSDB_PRIszt "(%" PRIu64 "+%" PRIu64 " bytes) to %" ROCKSDB_PRIszt
"+%" ROCKSDB_PRIszt " (%" PRIu64 "+%" PRIu64 " bytes)\n", "+%" ROCKSDB_PRIszt " (%" PRIu64 "+%" PRIu64 " bytes)\n",

2
db/compaction/compaction_picker_fifo.cc
View File

@ -244,7 +244,7 @@ Compaction* FIFOCompactionPicker::CompactRange(
assert(input_level == 0); assert(input_level == 0);
assert(output_level == 0); assert(output_level == 0);
*compaction_end = nullptr; *compaction_end = nullptr;
LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, ioptions_.info_log); LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, ioptions_.logger);
Compaction* c = PickCompaction(cf_name, mutable_cf_options, Compaction* c = PickCompaction(cf_name, mutable_cf_options,
mutable_db_options, vstorage, &log_buffer); mutable_db_options, vstorage, &log_buffer);
log_buffer.FlushBufferToLog(); log_buffer.FlushBufferToLog();

2
db/compaction/compaction_picker_universal.cc
View File

@ -486,7 +486,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
} }
#endif #endif
// update statistics // update statistics
RecordInHistogram(ioptions_.statistics, NUM_FILES_IN_SINGLE_COMPACTION, RecordInHistogram(ioptions_.stats, NUM_FILES_IN_SINGLE_COMPACTION,
c->inputs(0)->size()); c->inputs(0)->size());
picker_->RegisterCompaction(c); picker_->RegisterCompaction(c);

4
db/db_iter.cc
View File

@ -46,14 +46,14 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
: prefix_extractor_(mutable_cf_options.prefix_extractor.get()), : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
env_(_env), env_(_env),
clock_(cf_options.clock), clock_(cf_options.clock),
logger_(cf_options.info_log), logger_(cf_options.logger),
user_comparator_(cmp), user_comparator_(cmp),
merge_operator_(cf_options.merge_operator.get()), merge_operator_(cf_options.merge_operator.get()),
iter_(iter), iter_(iter),
version_(version), version_(version),
read_callback_(read_callback), read_callback_(read_callback),
sequence_(s), sequence_(s),
statistics_(cf_options.statistics), statistics_(cf_options.stats),
max_skip_(max_sequential_skip_in_iterations), max_skip_(max_sequential_skip_in_iterations),
max_skippable_internal_keys_(read_options.max_skippable_internal_keys), max_skippable_internal_keys_(read_options.max_skippable_internal_keys),
num_internal_keys_skipped_(0), num_internal_keys_skipped_(0),

10
db/memtable.cc
View File

@ -58,9 +58,9 @@ ImmutableMemTableOptions::ImmutableMemTableOptions(
inplace_update_num_locks(mutable_cf_options.inplace_update_num_locks), inplace_update_num_locks(mutable_cf_options.inplace_update_num_locks),
inplace_callback(ioptions.inplace_callback), inplace_callback(ioptions.inplace_callback),
max_successive_merges(mutable_cf_options.max_successive_merges), max_successive_merges(mutable_cf_options.max_successive_merges),
statistics(ioptions.statistics), statistics(ioptions.stats),
merge_operator(ioptions.merge_operator.get()), merge_operator(ioptions.merge_operator.get()),
info_log(ioptions.info_log), info_log(ioptions.logger),
allow_data_in_errors(ioptions.allow_data_in_errors) {} allow_data_in_errors(ioptions.allow_data_in_errors) {}
MemTable::MemTable(const InternalKeyComparator& cmp, MemTable::MemTable(const InternalKeyComparator& cmp,
@ -82,9 +82,9 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
mutable_cf_options.memtable_huge_page_size), mutable_cf_options.memtable_huge_page_size),
table_(ioptions.memtable_factory->CreateMemTableRep( table_(ioptions.memtable_factory->CreateMemTableRep(
comparator_, &arena_, mutable_cf_options.prefix_extractor.get(), comparator_, &arena_, mutable_cf_options.prefix_extractor.get(),
ioptions.info_log, column_family_id)), ioptions.logger, column_family_id)),
range_del_table_(SkipListFactory().CreateMemTableRep( range_del_table_(SkipListFactory().CreateMemTableRep(
comparator_, &arena_, nullptr /* transform */, ioptions.info_log, comparator_, &arena_, nullptr /* transform */, ioptions.logger,
column_family_id)), column_family_id)),
is_range_del_table_empty_(true), is_range_del_table_empty_(true),
data_size_(0), data_size_(0),
@ -120,7 +120,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
bloom_filter_.reset( bloom_filter_.reset(
new DynamicBloom(&arena_, moptions_.memtable_prefix_bloom_bits, new DynamicBloom(&arena_, moptions_.memtable_prefix_bloom_bits,
6 /* hard coded 6 probes */, 6 /* hard coded 6 probes */,
moptions_.memtable_huge_page_size, ioptions.info_log)); moptions_.memtable_huge_page_size, ioptions.logger));
} }
} }

14
db/table_cache.cc
View File

@ -110,7 +110,7 @@ Status TableCache::GetTableReader(
if (s.ok()) { if (s.ok()) {
s = ioptions_.fs->NewRandomAccessFile(fname, fopts, &file, nullptr); s = ioptions_.fs->NewRandomAccessFile(fname, fopts, &file, nullptr);
} }
RecordTick(ioptions_.statistics, NO_FILE_OPENS); RecordTick(ioptions_.stats, NO_FILE_OPENS);
if (s.IsPathNotFound()) { if (s.IsPathNotFound()) {
fname = Rocks2LevelTableFileName(fname); fname = Rocks2LevelTableFileName(fname);
s = PrepareIOFromReadOptions(ro, ioptions_.clock, fopts.io_options); s = PrepareIOFromReadOptions(ro, ioptions_.clock, fopts.io_options);
@ -118,18 +118,18 @@ Status TableCache::GetTableReader(
s = ioptions_.fs->NewRandomAccessFile(fname, file_options, &file, s = ioptions_.fs->NewRandomAccessFile(fname, file_options, &file,
nullptr); nullptr);
} }
RecordTick(ioptions_.statistics, NO_FILE_OPENS); RecordTick(ioptions_.stats, NO_FILE_OPENS);
} }
if (s.ok()) { if (s.ok()) {
if (!sequential_mode && ioptions_.advise_random_on_open) { if (!sequential_mode && ioptions_.advise_random_on_open) {
file->Hint(FSRandomAccessFile::kRandom); file->Hint(FSRandomAccessFile::kRandom);
} }
StopWatch sw(ioptions_.clock, ioptions_.statistics, TABLE_OPEN_IO_MICROS); StopWatch sw(ioptions_.clock, ioptions_.stats, TABLE_OPEN_IO_MICROS);
std::unique_ptr<RandomAccessFileReader> file_reader( std::unique_ptr<RandomAccessFileReader> file_reader(
new RandomAccessFileReader( new RandomAccessFileReader(
std::move(file), fname, ioptions_.clock, io_tracer_, std::move(file), fname, ioptions_.clock, io_tracer_,
record_read_stats ? ioptions_.statistics : nullptr, SST_READ_MICROS, record_read_stats ? ioptions_.stats : nullptr, SST_READ_MICROS,
file_read_hist, ioptions_.rate_limiter.get(), ioptions_.listeners)); file_read_hist, ioptions_.rate_limiter.get(), ioptions_.listeners));
s = ioptions_.table_factory->NewTableReader( s = ioptions_.table_factory->NewTableReader(
ro, ro,
@ -187,7 +187,7 @@ Status TableCache::FindTable(const ReadOptions& ro,
max_file_size_for_l0_meta_pin); max_file_size_for_l0_meta_pin);
if (!s.ok()) { if (!s.ok()) {
assert(table_reader == nullptr); assert(table_reader == nullptr);
RecordTick(ioptions_.statistics, NO_FILE_ERRORS); RecordTick(ioptions_.stats, NO_FILE_ERRORS);
// We do not cache error results so that if the error is transient, // We do not cache error results so that if the error is transient,
// or somebody repairs the file, we recover automatically. // or somebody repairs the file, we recover automatically.
} else { } else {
@ -375,10 +375,10 @@ bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
ioptions_.row_cache.get(), row_handle); ioptions_.row_cache.get(), row_handle);
replayGetContextLog(*found_row_cache_entry, user_key, get_context, replayGetContextLog(*found_row_cache_entry, user_key, get_context,
&value_pinner); &value_pinner);
RecordTick(ioptions_.statistics, ROW_CACHE_HIT); RecordTick(ioptions_.stats, ROW_CACHE_HIT);
found = true; found = true;
} else { } else {
RecordTick(ioptions_.statistics, ROW_CACHE_MISS); RecordTick(ioptions_.stats, ROW_CACHE_MISS);
} }
return found; return found;
} }

11
db/version_set.cc
View File

@ -1302,7 +1302,7 @@ Status Version::GetTableProperties(std::shared_ptr<const TableProperties>* tp,
if (!s.ok()) { if (!s.ok()) {
return s; return s;
} }
RecordTick(ioptions->statistics, NUMBER_DIRECT_LOAD_TABLE_PROPERTIES); RecordTick(ioptions->stats, NUMBER_DIRECT_LOAD_TABLE_PROPERTIES);
*tp = std::shared_ptr<const TableProperties>(raw_table_properties); *tp = std::shared_ptr<const TableProperties>(raw_table_properties);
return s; return s;
@ -1763,9 +1763,8 @@ Version::Version(ColumnFamilyData* column_family_data, VersionSet* vset,
: env_(vset->env_), : env_(vset->env_),
clock_(vset->clock_), clock_(vset->clock_),
cfd_(column_family_data), cfd_(column_family_data),
info_log_((cfd_ == nullptr) ? nullptr : cfd_->ioptions()->info_log), info_log_((cfd_ == nullptr) ? nullptr : cfd_->ioptions()->logger),
db_statistics_((cfd_ == nullptr) ? nullptr db_statistics_((cfd_ == nullptr) ? nullptr : cfd_->ioptions()->stats),
: cfd_->ioptions()->statistics),
table_cache_((cfd_ == nullptr) ? nullptr : cfd_->table_cache()), table_cache_((cfd_ == nullptr) ? nullptr : cfd_->table_cache()),
blob_file_cache_(cfd_ ? cfd_->blob_file_cache() : nullptr), blob_file_cache_(cfd_ ? cfd_->blob_file_cache() : nullptr),
merge_operator_( merge_operator_(
@ -2763,7 +2762,7 @@ void VersionStorageInfo::ComputeFilesMarkedForPeriodicCompaction(
status = ioptions.env->GetFileModificationTime( status = ioptions.env->GetFileModificationTime(
file_path, &file_modification_time); file_path, &file_modification_time);
if (!status.ok()) { if (!status.ok()) {
ROCKS_LOG_WARN(ioptions.info_log, ROCKS_LOG_WARN(ioptions.logger,
"Can't get file modification time: %s: %s", "Can't get file modification time: %s: %s",
file_path.c_str(), status.ToString().c_str()); file_path.c_str(), status.ToString().c_str());
continue; continue;
@ -3486,7 +3485,7 @@ void VersionStorageInfo::CalculateBaseBytes(const ImmutableCFOptions& ioptions,
// base_bytes_min. We set it be base_bytes_min. // base_bytes_min. We set it be base_bytes_min.
base_level_size = base_bytes_min + 1U; base_level_size = base_bytes_min + 1U;
base_level_ = first_non_empty_level; base_level_ = first_non_empty_level;
ROCKS_LOG_INFO(ioptions.info_log, ROCKS_LOG_INFO(ioptions.logger,
"More existing levels in DB than needed. " "More existing levels in DB than needed. "
"max_bytes_for_level_multiplier may not be guaranteed."); "max_bytes_for_level_multiplier may not be guaranteed.");
} else { } else {

8
options/cf_options.cc
View File

@ -793,9 +793,7 @@ ImmutableCFOptions::ImmutableCFOptions(const Options& options)
ImmutableCFOptions::ImmutableCFOptions(const ImmutableDBOptions& db_options, ImmutableCFOptions::ImmutableCFOptions(const ImmutableDBOptions& db_options,
const ColumnFamilyOptions& cf_options) const ColumnFamilyOptions& cf_options)
: logger(db_options.info_log), : compaction_style(cf_options.compaction_style),
stats(db_options.statistics),
compaction_style(cf_options.compaction_style),
compaction_pri(cf_options.compaction_pri), compaction_pri(cf_options.compaction_pri),
user_comparator(cf_options.comparator), user_comparator(cf_options.comparator),
internal_comparator(InternalKeyComparator(cf_options.comparator)), internal_comparator(InternalKeyComparator(cf_options.comparator)),
@ -810,8 +808,8 @@ ImmutableCFOptions::ImmutableCFOptions(const ImmutableDBOptions& db_options,
cf_options.max_write_buffer_size_to_maintain), cf_options.max_write_buffer_size_to_maintain),
inplace_update_support(cf_options.inplace_update_support), inplace_update_support(cf_options.inplace_update_support),
inplace_callback(cf_options.inplace_callback), inplace_callback(cf_options.inplace_callback),
info_log(logger.get()), logger(db_options.logger),
statistics(stats.get()), stats(db_options.stats),
rate_limiter(db_options.rate_limiter), rate_limiter(db_options.rate_limiter),
info_log_level(db_options.info_log_level), info_log_level(db_options.info_log_level),
env(db_options.env), env(db_options.env),

7
options/cf_options.h
View File

@ -20,9 +20,6 @@ namespace ROCKSDB_NAMESPACE {
// of DB. Raw pointers defined in this struct do not have ownership to the data // of DB. Raw pointers defined in this struct do not have ownership to the data
// they point to. Options contains std::shared_ptr to these data. // they point to. Options contains std::shared_ptr to these data.
struct ImmutableCFOptions { struct ImmutableCFOptions {
private:
std::shared_ptr<Logger> logger; // ImmutableDBOptions
std::shared_ptr<Statistics> stats; // ImmutableDBOptions
public: public:
static const char* kName() { return "ImmutableCFOptions"; } static const char* kName() { return "ImmutableCFOptions"; }
explicit ImmutableCFOptions(); explicit ImmutableCFOptions();
@ -57,9 +54,9 @@ struct ImmutableCFOptions {
Slice delta_value, Slice delta_value,
std::string* merged_value); std::string* merged_value);
Logger* info_log; // ImmutableDBOptions Logger* logger; // ImmutableDBOptions
Statistics* statistics; // ImmutableDBOptions Statistics* stats; // ImmutableDBOptions
std::shared_ptr<RateLimiter> rate_limiter; // ImmutableDBOptions std::shared_ptr<RateLimiter> rate_limiter; // ImmutableDBOptions

2
options/db_options.cc
View File

@ -586,6 +586,8 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
} else { } else {
clock = SystemClock::Default().get(); clock = SystemClock::Default().get();
} }
logger = info_log.get();
stats = statistics.get();
} }
void ImmutableDBOptions::Dump(Logger* log) const { void ImmutableDBOptions::Dump(Logger* log) const {

2
options/db_options.h
View File

@ -97,6 +97,8 @@ struct ImmutableDBOptions {
// Convenience/Helper objects that are not part of the base DBOptions // Convenience/Helper objects that are not part of the base DBOptions
std::shared_ptr<FileSystem> fs; std::shared_ptr<FileSystem> fs;
SystemClock* clock; SystemClock* clock;
Statistics* stats;
Logger* logger;
}; };
struct MutableDBOptions { struct MutableDBOptions {

31
table/block_based/block_based_table_builder.cc
View File

@ -491,7 +491,7 @@ struct BlockBasedTableBuilder::Rep {
context.column_family_name = column_family_name; context.column_family_name = column_family_name;
context.compaction_style = ioptions.compaction_style; context.compaction_style = ioptions.compaction_style;
context.level_at_creation = level_at_creation; context.level_at_creation = level_at_creation;
context.info_log = ioptions.info_log; context.info_log = ioptions.logger;
filter_builder.reset(CreateFilterBlockBuilder( filter_builder.reset(CreateFilterBlockBuilder(
ioptions, moptions, context, use_delta_encoding_for_index_values, ioptions, moptions, context, use_delta_encoding_for_index_values,
p_index_builder_)); p_index_builder_));
@ -512,7 +512,7 @@ struct BlockBasedTableBuilder::Rep {
} }
if (!ReifyDbHostIdProperty(ioptions.env, &db_host_id).ok()) { if (!ReifyDbHostIdProperty(ioptions.env, &db_host_id).ok()) {
ROCKS_LOG_INFO(ioptions.info_log, "db_host_id property will not be set"); ROCKS_LOG_INFO(ioptions.logger, "db_host_id property will not be set");
} }
} }
@ -855,7 +855,7 @@ BlockBasedTableBuilder::BlockBasedTableBuilder(
if (sanitized_table_options.format_version == 0 && if (sanitized_table_options.format_version == 0 &&
sanitized_table_options.checksum != kCRC32c) { sanitized_table_options.checksum != kCRC32c) {
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
ioptions.info_log, ioptions.logger,
"Silently converting format_version to 1 because checksum is " "Silently converting format_version to 1 because checksum is "
"non-default"); "non-default");
// silently convert format_version to 1 to keep consistent with current // silently convert format_version to 1 to keep consistent with current
@ -959,14 +959,14 @@ void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
// TODO offset passed in is not accurate for parallel compression case // TODO offset passed in is not accurate for parallel compression case
NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(), NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(),
r->table_properties_collectors, r->table_properties_collectors,
r->ioptions.info_log); r->ioptions.logger);
} else if (value_type == kTypeRangeDeletion) { } else if (value_type == kTypeRangeDeletion) {
r->range_del_block.Add(key, value); r->range_del_block.Add(key, value);
// TODO offset passed in is not accurate for parallel compression case // TODO offset passed in is not accurate for parallel compression case
NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(), NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(),
r->table_properties_collectors, r->table_properties_collectors,
r->ioptions.info_log); r->ioptions.logger);
} else { } else {
assert(false); assert(false);
} }
@ -1081,7 +1081,7 @@ void BlockBasedTableBuilder::CompressAndVerifyBlock(
StopWatchNano timer( StopWatchNano timer(
r->ioptions.clock, r->ioptions.clock,
ShouldReportDetailedTime(r->ioptions.env, r->ioptions.statistics)); ShouldReportDetailedTime(r->ioptions.env, r->ioptions.stats));
if (is_status_ok && raw_block_contents.size() < kCompressionSizeLimit) { if (is_status_ok && raw_block_contents.size() < kCompressionSizeLimit) {
if (is_data_block) { if (is_data_block) {
@ -1145,7 +1145,7 @@ void BlockBasedTableBuilder::CompressAndVerifyBlock(
if (!compressed_ok) { if (!compressed_ok) {
// The result of the compression was invalid. abort. // The result of the compression was invalid. abort.
abort_compression = true; abort_compression = true;
ROCKS_LOG_ERROR(r->ioptions.info_log, ROCKS_LOG_ERROR(r->ioptions.logger,
"Decompressed block did not match raw block"); "Decompressed block did not match raw block");
*out_status = *out_status =
Status::Corruption("Decompressed block did not match raw block"); Status::Corruption("Decompressed block did not match raw block");
@ -1173,19 +1173,19 @@ void BlockBasedTableBuilder::CompressAndVerifyBlock(
// Abort compression if the block is too big, or did not pass // Abort compression if the block is too big, or did not pass
// verification. // verification.
if (abort_compression) { if (abort_compression) {
RecordTick(r->ioptions.statistics, NUMBER_BLOCK_NOT_COMPRESSED); RecordTick(r->ioptions.stats, NUMBER_BLOCK_NOT_COMPRESSED);
*type = kNoCompression; *type = kNoCompression;
*block_contents = raw_block_contents; *block_contents = raw_block_contents;
} else if (*type != kNoCompression) { } else if (*type != kNoCompression) {
if (ShouldReportDetailedTime(r->ioptions.env, r->ioptions.statistics)) { if (ShouldReportDetailedTime(r->ioptions.env, r->ioptions.stats)) {
RecordTimeToHistogram(r->ioptions.statistics, COMPRESSION_TIMES_NANOS, RecordTimeToHistogram(r->ioptions.stats, COMPRESSION_TIMES_NANOS,
timer.ElapsedNanos()); timer.ElapsedNanos());
} }
RecordInHistogram(r->ioptions.statistics, BYTES_COMPRESSED, RecordInHistogram(r->ioptions.stats, BYTES_COMPRESSED,
raw_block_contents.size()); raw_block_contents.size());
RecordTick(r->ioptions.statistics, NUMBER_BLOCK_COMPRESSED); RecordTick(r->ioptions.stats, NUMBER_BLOCK_COMPRESSED);
} else if (*type != r->compression_type) { } else if (*type != r->compression_type) {
RecordTick(r->ioptions.statistics, NUMBER_BLOCK_NOT_COMPRESSED); RecordTick(r->ioptions.stats, NUMBER_BLOCK_NOT_COMPRESSED);
} }
} }
@ -1196,8 +1196,7 @@ void BlockBasedTableBuilder::WriteRawBlock(const Slice& block_contents,
Rep* r = rep_; Rep* r = rep_;
Status s = Status::OK(); Status s = Status::OK();
IOStatus io_s = IOStatus::OK(); IOStatus io_s = IOStatus::OK();
StopWatch sw(r->ioptions.clock, r->ioptions.statistics, StopWatch sw(r->ioptions.clock, r->ioptions.stats, WRITE_RAW_BLOCK_MICROS);
WRITE_RAW_BLOCK_MICROS);
handle->set_offset(r->get_offset()); handle->set_offset(r->get_offset());
handle->set_size(block_contents.size()); handle->set_size(block_contents.size());
assert(status().ok()); assert(status().ok());
@ -1590,7 +1589,7 @@ void BlockBasedTableBuilder::WritePropertiesBlock(
// Add use collected properties // Add use collected properties
NotifyCollectTableCollectorsOnFinish(rep_->table_properties_collectors, NotifyCollectTableCollectorsOnFinish(rep_->table_properties_collectors,
rep_->ioptions.info_log, rep_->ioptions.logger,
&property_block_builder); &property_block_builder);
WriteRawBlock(property_block_builder.Finish(), kNoCompression, WriteRawBlock(property_block_builder.Finish(), kNoCompression,

78
table/block_based/block_based_table_reader.cc
View File

@ -166,8 +166,8 @@ Status ReadBlockFromFile(
Status s = block_fetcher.ReadBlockContents(); Status s = block_fetcher.ReadBlockContents();
if (s.ok()) { if (s.ok()) {
result->reset(BlocklikeTraits<TBlocklike>::Create( result->reset(BlocklikeTraits<TBlocklike>::Create(
std::move(contents), read_amp_bytes_per_bit, ioptions.statistics, std::move(contents), read_amp_bytes_per_bit, ioptions.stats, using_zstd,
using_zstd, filter_policy)); filter_policy));
} }
return s; return s;
@ -221,7 +221,7 @@ CacheAllocationPtr CopyBufferToHeap(MemoryAllocator* allocator, Slice& buf) {
void BlockBasedTable::UpdateCacheHitMetrics(BlockType block_type, void BlockBasedTable::UpdateCacheHitMetrics(BlockType block_type,
GetContext* get_context, GetContext* get_context,
size_t usage) const { size_t usage) const {
Statistics* const statistics = rep_->ioptions.statistics; Statistics* const statistics = rep_->ioptions.stats;
PERF_COUNTER_ADD(block_cache_hit_count, 1); PERF_COUNTER_ADD(block_cache_hit_count, 1);
PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1, PERF_COUNTER_BY_LEVEL_ADD(block_cache_hit_count, 1,
@ -279,7 +279,7 @@ void BlockBasedTable::UpdateCacheHitMetrics(BlockType block_type,
void BlockBasedTable::UpdateCacheMissMetrics(BlockType block_type, void BlockBasedTable::UpdateCacheMissMetrics(BlockType block_type,
GetContext* get_context) const { GetContext* get_context) const {
Statistics* const statistics = rep_->ioptions.statistics; Statistics* const statistics = rep_->ioptions.stats;
// TODO: introduce aggregate (not per-level) block cache miss count // TODO: introduce aggregate (not per-level) block cache miss count
PERF_COUNTER_BY_LEVEL_ADD(block_cache_miss_count, 1, PERF_COUNTER_BY_LEVEL_ADD(block_cache_miss_count, 1,
@ -333,7 +333,7 @@ void BlockBasedTable::UpdateCacheInsertionMetrics(BlockType block_type,
GetContext* get_context, GetContext* get_context,
size_t usage, size_t usage,
bool redundant) const { bool redundant) const {
Statistics* const statistics = rep_->ioptions.statistics; Statistics* const statistics = rep_->ioptions.stats;
// TODO: introduce perf counters for block cache insertions // TODO: introduce perf counters for block cache insertions
if (get_context) { if (get_context) {
@ -425,7 +425,7 @@ void BlockBasedTable::UpdateCacheInsertionMetrics(BlockType block_type,
Cache::Handle* BlockBasedTable::GetEntryFromCache( Cache::Handle* BlockBasedTable::GetEntryFromCache(
Cache* block_cache, const Slice& key, BlockType block_type, Cache* block_cache, const Slice& key, BlockType block_type,
GetContext* get_context) const { GetContext* get_context) const {
auto cache_handle = block_cache->Lookup(key, rep_->ioptions.statistics); auto cache_handle = block_cache->Lookup(key, rep_->ioptions.stats);
if (cache_handle != nullptr) { if (cache_handle != nullptr) {
UpdateCacheHitMetrics(block_type, get_context, UpdateCacheHitMetrics(block_type, get_context,
@ -662,7 +662,7 @@ Status BlockBasedTable::Open(
PersistentCacheOptions(rep->table_options.persistent_cache, PersistentCacheOptions(rep->table_options.persistent_cache,
std::string(rep->persistent_cache_key_prefix, std::string(rep->persistent_cache_key_prefix,
rep->persistent_cache_key_prefix_size), rep->persistent_cache_key_prefix_size),
rep->ioptions.statistics); rep->ioptions.stats);
// Meta-blocks are not dictionary compressed. Explicitly set the dictionary // Meta-blocks are not dictionary compressed. Explicitly set the dictionary
// handle to null, otherwise it may be seen as uninitialized during the below // handle to null, otherwise it may be seen as uninitialized during the below
@ -805,7 +805,7 @@ Status BlockBasedTable::ReadPropertiesBlock(
s = SeekToPropertiesBlock(meta_iter, &found_properties_block); s = SeekToPropertiesBlock(meta_iter, &found_properties_block);
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_WARN(rep_->ioptions.info_log, ROCKS_LOG_WARN(rep_->ioptions.logger,
"Error when seeking to properties block from file: %s", "Error when seeking to properties block from file: %s",
s.ToString().c_str()); s.ToString().c_str());
} else if (found_properties_block) { } else if (found_properties_block) {
@ -832,7 +832,7 @@ Status BlockBasedTable::ReadPropertiesBlock(
} }
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_WARN(rep_->ioptions.info_log, ROCKS_LOG_WARN(rep_->ioptions.logger,
"Encountered error while reading data from properties " "Encountered error while reading data from properties "
"block %s", "block %s",
s.ToString().c_str()); s.ToString().c_str());
@ -849,7 +849,7 @@ Status BlockBasedTable::ReadPropertiesBlock(
CompressionTypeToString(kZSTDNotFinalCompression)); CompressionTypeToString(kZSTDNotFinalCompression));
} }
} else { } else {
ROCKS_LOG_ERROR(rep_->ioptions.info_log, ROCKS_LOG_ERROR(rep_->ioptions.logger,
"Cannot find Properties block from file."); "Cannot find Properties block from file.");
} }
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
@ -864,11 +864,10 @@ Status BlockBasedTable::ReadPropertiesBlock(
rep_->whole_key_filtering &= rep_->whole_key_filtering &=
IsFeatureSupported(*(rep_->table_properties), IsFeatureSupported(*(rep_->table_properties),
BlockBasedTablePropertyNames::kWholeKeyFiltering, BlockBasedTablePropertyNames::kWholeKeyFiltering,
rep_->ioptions.info_log); rep_->ioptions.logger);
rep_->prefix_filtering &= rep_->prefix_filtering &= IsFeatureSupported(
IsFeatureSupported(*(rep_->table_properties), *(rep_->table_properties),
BlockBasedTablePropertyNames::kPrefixFiltering, BlockBasedTablePropertyNames::kPrefixFiltering, rep_->ioptions.logger);
rep_->ioptions.info_log);
rep_->index_key_includes_seq = rep_->index_key_includes_seq =
rep_->table_properties->index_key_is_user_key == 0; rep_->table_properties->index_key_is_user_key == 0;
@ -891,7 +890,7 @@ Status BlockBasedTable::ReadPropertiesBlock(
s = GetGlobalSequenceNumber(*(rep_->table_properties), largest_seqno, s = GetGlobalSequenceNumber(*(rep_->table_properties), largest_seqno,
&(rep_->global_seqno)); &(rep_->global_seqno));
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_ERROR(rep_->ioptions.info_log, "%s", s.ToString().c_str()); ROCKS_LOG_ERROR(rep_->ioptions.logger, "%s", s.ToString().c_str());
} }
} }
return s; return s;
@ -908,7 +907,7 @@ Status BlockBasedTable::ReadRangeDelBlock(
s = SeekToRangeDelBlock(meta_iter, &found_range_del_block, &range_del_handle); s = SeekToRangeDelBlock(meta_iter, &found_range_del_block, &range_del_handle);
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
rep_->ioptions.info_log, rep_->ioptions.logger,
"Error when seeking to range delete tombstones block from file: %s", "Error when seeking to range delete tombstones block from file: %s",
s.ToString().c_str()); s.ToString().c_str());
} else if (found_range_del_block && !range_del_handle.IsNull()) { } else if (found_range_del_block && !range_del_handle.IsNull()) {
@ -920,7 +919,7 @@ Status BlockBasedTable::ReadRangeDelBlock(
s = iter->status(); s = iter->status();
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
rep_->ioptions.info_log, rep_->ioptions.logger,
"Encountered error while reading data from range del block %s", "Encountered error while reading data from range del block %s",
s.ToString().c_str()); s.ToString().c_str());
IGNORE_STATUS_IF_ERROR(s); IGNORE_STATUS_IF_ERROR(s);
@ -1151,7 +1150,7 @@ Status BlockBasedTable::ReadMetaIndexBlock(
nullptr /* filter_policy */); nullptr /* filter_policy */);
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_ERROR(rep_->ioptions.info_log, ROCKS_LOG_ERROR(rep_->ioptions.logger,
"Encountered error while reading data from properties" "Encountered error while reading data from properties"
" block %s", " block %s",
s.ToString().c_str()); s.ToString().c_str());
@ -1206,7 +1205,7 @@ Status BlockBasedTable::GetDataBlockFromCache(
block_cache_compressed_handle = block_cache_compressed_handle =
block_cache_compressed->Lookup(compressed_block_cache_key); block_cache_compressed->Lookup(compressed_block_cache_key);
Statistics* statistics = rep_->ioptions.statistics; Statistics* statistics = rep_->ioptions.stats;
// if we found in the compressed cache, then uncompress and insert into // if we found in the compressed cache, then uncompress and insert into
// uncompressed cache // uncompressed cache
@ -1291,7 +1290,7 @@ Status BlockBasedTable::PutDataBlockToCache(
assert(cached_block->IsEmpty()); assert(cached_block->IsEmpty());
Status s; Status s;
Statistics* statistics = ioptions.statistics; Statistics* statistics = ioptions.stats;
std::unique_ptr<TBlocklike> block_holder; std::unique_ptr<TBlocklike> block_holder;
if (raw_block_comp_type != kNoCompression) { if (raw_block_comp_type != kNoCompression) {
@ -1422,8 +1421,7 @@ DataBlockIter* BlockBasedTable::InitBlockIterator<DataBlockIter>(
DataBlockIter* input_iter, bool block_contents_pinned) { DataBlockIter* input_iter, bool block_contents_pinned) {
return block->NewDataIterator(rep->internal_comparator.user_comparator(), return block->NewDataIterator(rep->internal_comparator.user_comparator(),
rep->get_global_seqno(block_type), input_iter, rep->get_global_seqno(block_type), input_iter,
rep->ioptions.statistics, rep->ioptions.stats, block_contents_pinned);
block_contents_pinned);
} }
template <> template <>
@ -1432,7 +1430,7 @@ IndexBlockIter* BlockBasedTable::InitBlockIterator<IndexBlockIter>(
IndexBlockIter* input_iter, bool block_contents_pinned) { IndexBlockIter* input_iter, bool block_contents_pinned) {
return block->NewIndexIterator( return block->NewIndexIterator(
rep->internal_comparator.user_comparator(), rep->internal_comparator.user_comparator(),
rep->get_global_seqno(block_type), input_iter, rep->ioptions.statistics, rep->get_global_seqno(block_type), input_iter, rep->ioptions.stats,
/* total_order_seek */ true, rep->index_has_first_key, /* total_order_seek */ true, rep->index_has_first_key,
rep->index_key_includes_seq, rep->index_value_is_full, rep->index_key_includes_seq, rep->index_value_is_full,
block_contents_pinned); block_contents_pinned);
@ -1492,7 +1490,7 @@ Status BlockBasedTable::MaybeReadBlockAndLoadToCache(
// Can't find the block from the cache. If I/O is allowed, read from the // Can't find the block from the cache. If I/O is allowed, read from the
// file. // file.
if (block_entry->GetValue() == nullptr && !no_io && ro.fill_cache) { if (block_entry->GetValue() == nullptr && !no_io && ro.fill_cache) {
Statistics* statistics = rep_->ioptions.statistics; Statistics* statistics = rep_->ioptions.stats;
const bool maybe_compressed = const bool maybe_compressed =
block_type != BlockType::kFilter && block_type != BlockType::kFilter &&
block_type != BlockType::kCompressionDictionary && block_type != BlockType::kCompressionDictionary &&
@ -1886,7 +1884,7 @@ void BlockBasedTable::RetrieveMultipleBlocks(
} }
if (s.ok()) { if (s.ok()) {
(*results)[idx_in_batch].SetOwnedValue(new Block( (*results)[idx_in_batch].SetOwnedValue(new Block(
std::move(contents), read_amp_bytes_per_bit, ioptions.statistics)); std::move(contents), read_amp_bytes_per_bit, ioptions.stats));
} }
} }
(*statuses)[idx_in_batch] = s; (*statuses)[idx_in_batch] = s;
@ -1935,7 +1933,7 @@ Status BlockBasedTable::RetrieveBlock(
std::unique_ptr<TBlocklike> block; std::unique_ptr<TBlocklike> block;
{ {
StopWatch sw(rep_->ioptions.clock, rep_->ioptions.statistics, StopWatch sw(rep_->ioptions.clock, rep_->ioptions.stats,
READ_BLOCK_GET_MICROS); READ_BLOCK_GET_MICROS);
s = ReadBlockFromFile( s = ReadBlockFromFile(
rep_->file.get(), prefetch_buffer, rep_->footer, ro, handle, &block, rep_->file.get(), prefetch_buffer, rep_->footer, ro, handle, &block,
@ -2149,7 +2147,7 @@ bool BlockBasedTable::PrefixMayMatch(
} }
if (filter_checked) { if (filter_checked) {
Statistics* statistics = rep_->ioptions.statistics; Statistics* statistics = rep_->ioptions.stats;
RecordTick(statistics, BLOOM_FILTER_PREFIX_CHECKED); RecordTick(statistics, BLOOM_FILTER_PREFIX_CHECKED);
if (!may_match) { if (!may_match) {
RecordTick(statistics, BLOOM_FILTER_PREFIX_USEFUL); RecordTick(statistics, BLOOM_FILTER_PREFIX_USEFUL);
@ -2232,7 +2230,7 @@ bool BlockBasedTable::FullFilterKeyMayMatch(
may_match = false; may_match = false;
} }
if (may_match) { if (may_match) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_FULL_POSITIVE); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_POSITIVE);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, 1, rep_->level); PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, 1, rep_->level);
} }
return may_match; return may_match;
@ -2253,14 +2251,13 @@ void BlockBasedTable::FullFilterKeysMayMatch(
lookup_context); lookup_context);
uint64_t after_keys = range->KeysLeft(); uint64_t after_keys = range->KeysLeft();
if (after_keys) { if (after_keys) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_FULL_POSITIVE, RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_POSITIVE, after_keys);
after_keys);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, after_keys, PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_positive, after_keys,
rep_->level); rep_->level);
} }
uint64_t filtered_keys = before_keys - after_keys; uint64_t filtered_keys = before_keys - after_keys;
if (filtered_keys) { if (filtered_keys) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_USEFUL, filtered_keys); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_USEFUL, filtered_keys);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, filtered_keys, PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, filtered_keys,
rep_->level); rep_->level);
} }
@ -2269,12 +2266,11 @@ void BlockBasedTable::FullFilterKeysMayMatch(
prefix_extractor->Name()) == 0) { prefix_extractor->Name()) == 0) {
filter->PrefixesMayMatch(range, prefix_extractor, kNotValid, false, filter->PrefixesMayMatch(range, prefix_extractor, kNotValid, false,
lookup_context); lookup_context);
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_PREFIX_CHECKED, RecordTick(rep_->ioptions.stats, BLOOM_FILTER_PREFIX_CHECKED, before_keys);
before_keys);
uint64_t after_keys = range->KeysLeft(); uint64_t after_keys = range->KeysLeft();
uint64_t filtered_keys = before_keys - after_keys; uint64_t filtered_keys = before_keys - after_keys;
if (filtered_keys) { if (filtered_keys) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_PREFIX_USEFUL, RecordTick(rep_->ioptions.stats, BLOOM_FILTER_PREFIX_USEFUL,
filtered_keys); filtered_keys);
} }
} }
@ -2310,7 +2306,7 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
get_context, &lookup_context); get_context, &lookup_context);
TEST_SYNC_POINT("BlockBasedTable::Get:AfterFilterMatch"); TEST_SYNC_POINT("BlockBasedTable::Get:AfterFilterMatch");
if (!may_match) { if (!may_match) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_USEFUL); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_USEFUL);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, rep_->level); PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, rep_->level);
} else { } else {
IndexBlockIter iiter_on_stack; IndexBlockIter iiter_on_stack;
@ -2347,7 +2343,7 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
// Not found // Not found
// TODO: think about interaction with Merge. If a user key cannot // TODO: think about interaction with Merge. If a user key cannot
// cross one data block, we should be fine. // cross one data block, we should be fine.
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_USEFUL); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_USEFUL);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, rep_->level); PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_useful, 1, rep_->level);
break; break;
} }
@ -2455,7 +2451,7 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
} }
} }
if (matched && filter != nullptr && !filter->IsBlockBased()) { if (matched && filter != nullptr && !filter->IsBlockBased()) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_FULL_TRUE_POSITIVE); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_TRUE_POSITIVE);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_true_positive, 1, PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_true_positive, 1,
rep_->level); rep_->level);
} }
@ -2799,7 +2795,7 @@ void BlockBasedTable::MultiGet(const ReadOptions& read_options,
} while (iiter->Valid()); } while (iiter->Valid());
if (matched && filter != nullptr && !filter->IsBlockBased()) { if (matched && filter != nullptr && !filter->IsBlockBased()) {
RecordTick(rep_->ioptions.statistics, BLOOM_FILTER_FULL_TRUE_POSITIVE); RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_TRUE_POSITIVE);
PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_true_positive, 1, PERF_COUNTER_BY_LEVEL_ADD(bloom_filter_full_true_positive, 1,
rep_->level); rep_->level);
} }
@ -3091,7 +3087,7 @@ Status BlockBasedTable::CreateIndexReader(
auto meta_index_iter = preloaded_meta_index_iter; auto meta_index_iter = preloaded_meta_index_iter;
bool should_fallback = false; bool should_fallback = false;
if (rep_->internal_prefix_transform.get() == nullptr) { if (rep_->internal_prefix_transform.get() == nullptr) {
ROCKS_LOG_WARN(rep_->ioptions.info_log, ROCKS_LOG_WARN(rep_->ioptions.logger,
"No prefix extractor passed in. Fall back to binary" "No prefix extractor passed in. Fall back to binary"
" search index."); " search index.");
should_fallback = true; should_fallback = true;
@ -3101,7 +3097,7 @@ Status BlockBasedTable::CreateIndexReader(
if (!s.ok()) { if (!s.ok()) {
// we simply fall back to binary search in case there is any // we simply fall back to binary search in case there is any
// problem with prefix hash index loading. // problem with prefix hash index loading.
ROCKS_LOG_WARN(rep_->ioptions.info_log, ROCKS_LOG_WARN(rep_->ioptions.logger,
"Unable to read the metaindex block." "Unable to read the metaindex block."
" Fall back to binary search index."); " Fall back to binary search index.");
should_fallback = true; should_fallback = true;

2
table/block_based/mock_block_based_table.h
View File

@ -47,7 +47,7 @@ class MockBlockBasedTableTester {
context.column_family_name = "mock_cf"; context.column_family_name = "mock_cf";
context.compaction_style = ioptions_.compaction_style; context.compaction_style = ioptions_.compaction_style;
context.level_at_creation = kMockLevel; context.level_at_creation = kMockLevel;
context.info_log = ioptions_.info_log; context.info_log = ioptions_.logger;
return BloomFilterPolicy::GetBuilderFromContext(context); return BloomFilterPolicy::GetBuilderFromContext(context);
} }
}; };

2
table/block_based/partitioned_filter_block.cc
View File

@ -430,7 +430,7 @@ Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
Status s = GetOrReadFilterBlock(false /* no_io */, nullptr /* get_context */, Status s = GetOrReadFilterBlock(false /* no_io */, nullptr /* get_context */,
&lookup_context, &filter_block); &lookup_context, &filter_block);
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_ERROR(rep->ioptions.info_log, ROCKS_LOG_ERROR(rep->ioptions.logger,
"Error retrieving top-level filter block while trying to " "Error retrieving top-level filter block while trying to "
"cache filter partitions: %s", "cache filter partitions: %s",
s.ToString().c_str()); s.ToString().c_str());

2
table/block_based/uncompression_dict_reader.cc
View File

@ -64,7 +64,7 @@ Status UncompressionDictReader::ReadUncompressionDictionary(
if (!s.ok()) { if (!s.ok()) {
ROCKS_LOG_WARN( ROCKS_LOG_WARN(
rep->ioptions.info_log, rep->ioptions.logger,
"Encountered error while reading data from compression dictionary " "Encountered error while reading data from compression dictionary "
"block %s", "block %s",
s.ToString().c_str()); s.ToString().c_str());

8
table/block_fetcher.cc
View File

@ -45,9 +45,9 @@ inline bool BlockFetcher::TryGetUncompressBlockFromPersistentCache() {
return true; return true;
} else { } else {
// uncompressed page is not found // uncompressed page is not found
if (ioptions_.info_log && !status.IsNotFound()) { if (ioptions_.logger && !status.IsNotFound()) {
assert(!status.ok()); assert(!status.ok());
ROCKS_LOG_INFO(ioptions_.info_log, ROCKS_LOG_INFO(ioptions_.logger,
"Error reading from persistent cache. %s", "Error reading from persistent cache. %s",
status.ToString().c_str()); status.ToString().c_str());
} }
@ -89,9 +89,9 @@ inline bool BlockFetcher::TryGetCompressedBlockFromPersistentCache() {
used_buf_ = heap_buf_.get(); used_buf_ = heap_buf_.get();
slice_ = Slice(heap_buf_.get(), block_size_); slice_ = Slice(heap_buf_.get(), block_size_);
return true; return true;
} else if (!io_status_.IsNotFound() && ioptions_.info_log) { } else if (!io_status_.IsNotFound() && ioptions_.logger) {
assert(!io_status_.ok()); assert(!io_status_.ok());
ROCKS_LOG_INFO(ioptions_.info_log, ROCKS_LOG_INFO(ioptions_.logger,
"Error reading from persistent cache. %s", "Error reading from persistent cache. %s",
io_status_.ToString().c_str()); io_status_.ToString().c_str());
} }

12
table/format.cc
View File

@ -353,8 +353,8 @@ Status UncompressBlockContentsForCompressionType(
assert(uncompression_info.type() != kNoCompression && assert(uncompression_info.type() != kNoCompression &&
"Invalid compression type"); "Invalid compression type");
StopWatchNano timer(ioptions.clock, ShouldReportDetailedTime( StopWatchNano timer(ioptions.clock,
ioptions.env, ioptions.statistics)); ShouldReportDetailedTime(ioptions.env, ioptions.stats));
size_t uncompressed_size = 0; size_t uncompressed_size = 0;
CacheAllocationPtr ubuf = CacheAllocationPtr ubuf =
UncompressData(uncompression_info, data, n, &uncompressed_size, UncompressData(uncompression_info, data, n, &uncompressed_size,
@ -367,13 +367,13 @@ Status UncompressBlockContentsForCompressionType(
*contents = BlockContents(std::move(ubuf), uncompressed_size); *contents = BlockContents(std::move(ubuf), uncompressed_size);
if (ShouldReportDetailedTime(ioptions.env, ioptions.statistics)) { if (ShouldReportDetailedTime(ioptions.env, ioptions.stats)) {
RecordTimeToHistogram(ioptions.statistics, DECOMPRESSION_TIMES_NANOS, RecordTimeToHistogram(ioptions.stats, DECOMPRESSION_TIMES_NANOS,
timer.ElapsedNanos()); timer.ElapsedNanos());
} }
RecordTimeToHistogram(ioptions.statistics, BYTES_DECOMPRESSED, RecordTimeToHistogram(ioptions.stats, BYTES_DECOMPRESSED,
contents->data.size()); contents->data.size());
RecordTick(ioptions.statistics, NUMBER_BLOCK_DECOMPRESSED); RecordTick(ioptions.stats, NUMBER_BLOCK_DECOMPRESSED);
TEST_SYNC_POINT_CALLBACK( TEST_SYNC_POINT_CALLBACK(
"UncompressBlockContentsForCompressionType:TamperWithReturnValue", "UncompressBlockContentsForCompressionType:TamperWithReturnValue",

2
table/meta_blocks.cc
View File

@ -329,7 +329,7 @@ Status ReadProperties(const ReadOptions& read_options,
auto error_msg = auto error_msg =
"Detect malformed value in properties meta-block:" "Detect malformed value in properties meta-block:"
"\tkey: " + key + "\tval: " + raw_val.ToString(); "\tkey: " + key + "\tval: " + raw_val.ToString();
ROCKS_LOG_ERROR(ioptions.info_log, "%s", error_msg.c_str()); ROCKS_LOG_ERROR(ioptions.logger, "%s", error_msg.c_str());
continue; continue;
} }
*(pos->second) = val; *(pos->second) = val;

11
table/plain/plain_table_builder.cc
View File

@ -102,7 +102,7 @@ PlainTableBuilder::PlainTableBuilder(
properties_.db_session_id = db_session_id; properties_.db_session_id = db_session_id;
properties_.db_host_id = ioptions.db_host_id; properties_.db_host_id = ioptions.db_host_id;
if (!ReifyDbHostIdProperty(ioptions_.env, &properties_.db_host_id).ok()) { if (!ReifyDbHostIdProperty(ioptions_.env, &properties_.db_host_id).ok()) {
ROCKS_LOG_INFO(ioptions_.info_log, "db_host_id property will not be set"); ROCKS_LOG_INFO(ioptions_.logger, "db_host_id property will not be set");
} }
properties_.prefix_extractor_name = moptions_.prefix_extractor != nullptr properties_.prefix_extractor_name = moptions_.prefix_extractor != nullptr
? moptions_.prefix_extractor->Name() ? moptions_.prefix_extractor->Name()
@ -193,7 +193,7 @@ void PlainTableBuilder::Add(const Slice& key, const Slice& value) {
// notify property collectors // notify property collectors
NotifyCollectTableCollectorsOnAdd( NotifyCollectTableCollectorsOnAdd(
key, value, offset_, table_properties_collectors_, ioptions_.info_log); key, value, offset_, table_properties_collectors_, ioptions_.logger);
status_ = io_status_; status_ = io_status_;
} }
@ -219,7 +219,7 @@ Status PlainTableBuilder::Finish() {
bloom_block_.SetTotalBits( bloom_block_.SetTotalBits(
&arena_, &arena_,
static_cast<uint32_t>(properties_.num_entries) * bloom_bits_per_key_, static_cast<uint32_t>(properties_.num_entries) * bloom_bits_per_key_,
ioptions_.bloom_locality, huge_page_tlb_size_, ioptions_.info_log); ioptions_.bloom_locality, huge_page_tlb_size_, ioptions_.logger);
PutVarint32(&properties_.user_collected_properties PutVarint32(&properties_.user_collected_properties
[PlainTablePropertyNames::kNumBloomBlocks], [PlainTablePropertyNames::kNumBloomBlocks],
@ -263,9 +263,8 @@ Status PlainTableBuilder::Finish() {
property_block_builder.Add(properties_.user_collected_properties); property_block_builder.Add(properties_.user_collected_properties);
// -- Add user collected properties // -- Add user collected properties
NotifyCollectTableCollectorsOnFinish(table_properties_collectors_, NotifyCollectTableCollectorsOnFinish(
ioptions_.info_log, table_properties_collectors_, ioptions_.logger, &property_block_builder);
&property_block_builder);
// -- Write property block // -- Write property block
BlockHandle property_block_handle; BlockHandle property_block_handle;

8
table/plain/plain_table_index.cc
View File

@ -98,7 +98,7 @@ Slice PlainTableIndexBuilder::Finish() {
BucketizeIndexes(&hash_to_offsets, &entries_per_bucket); BucketizeIndexes(&hash_to_offsets, &entries_per_bucket);
keys_per_prefix_hist_.Add(num_keys_per_prefix_); keys_per_prefix_hist_.Add(num_keys_per_prefix_);
ROCKS_LOG_INFO(ioptions_.info_log, "Number of Keys per prefix Histogram: %s", ROCKS_LOG_INFO(ioptions_.logger, "Number of Keys per prefix Histogram: %s",
keys_per_prefix_hist_.ToString().c_str()); keys_per_prefix_hist_.ToString().c_str());
// From the temp data structure, populate indexes. // From the temp data structure, populate indexes.
@ -153,12 +153,12 @@ void PlainTableIndexBuilder::BucketizeIndexes(
Slice PlainTableIndexBuilder::FillIndexes( Slice PlainTableIndexBuilder::FillIndexes(
const std::vector<IndexRecord*>& hash_to_offsets, const std::vector<IndexRecord*>& hash_to_offsets,
const std::vector<uint32_t>& entries_per_bucket) { const std::vector<uint32_t>& entries_per_bucket) {
ROCKS_LOG_DEBUG(ioptions_.info_log, ROCKS_LOG_DEBUG(ioptions_.logger,
"Reserving %" PRIu32 " bytes for plain table's sub_index", "Reserving %" PRIu32 " bytes for plain table's sub_index",
sub_index_size_); sub_index_size_);
auto total_allocate_size = GetTotalSize(); auto total_allocate_size = GetTotalSize();
char* allocated = arena_->AllocateAligned( char* allocated = arena_->AllocateAligned(
total_allocate_size, huge_page_tlb_size_, ioptions_.info_log); total_allocate_size, huge_page_tlb_size_, ioptions_.logger);
auto temp_ptr = EncodeVarint32(allocated, index_size_); auto temp_ptr = EncodeVarint32(allocated, index_size_);
uint32_t* index = uint32_t* index =
@ -198,7 +198,7 @@ Slice PlainTableIndexBuilder::FillIndexes(
} }
assert(sub_index_offset == sub_index_size_); assert(sub_index_offset == sub_index_size_);
ROCKS_LOG_DEBUG(ioptions_.info_log, ROCKS_LOG_DEBUG(ioptions_.logger,
"hash table size: %" PRIu32 ", suffix_map length %" PRIu32, "hash table size: %" PRIu32 ", suffix_map length %" PRIu32,
index_size_, sub_index_size_); index_size_, sub_index_size_);
return Slice(allocated, GetTotalSize()); return Slice(allocated, GetTotalSize());

2
table/plain/plain_table_reader.cc
View File

@ -277,7 +277,7 @@ void PlainTableReader::AllocateBloom(int bloom_bits_per_key, int num_keys,
if (bloom_total_bits > 0) { if (bloom_total_bits > 0) {
enable_bloom_ = true; enable_bloom_ = true;
bloom_.SetTotalBits(&arena_, bloom_total_bits, ioptions_.bloom_locality, bloom_.SetTotalBits(&arena_, bloom_total_bits, ioptions_.bloom_locality,
huge_page_tlb_size, ioptions_.info_log); huge_page_tlb_size, ioptions_.logger);
} }
} }

2
table/table_reader_bench.cc
View File

@ -177,7 +177,7 @@ void TableReaderBenchmark(Options& opts, EnvOptions& env_options,
SequenceNumber max_covering_tombstone_seq = 0; SequenceNumber max_covering_tombstone_seq = 0;
GetContext get_context( GetContext get_context(
ioptions.user_comparator, ioptions.merge_operator.get(), ioptions.user_comparator, ioptions.merge_operator.get(),
ioptions.info_log, ioptions.statistics, GetContext::kNotFound, ioptions.logger, ioptions.stats, GetContext::kNotFound,
Slice(key), &value, nullptr, &merge_context, true, Slice(key), &value, nullptr, &merge_context, true,
&max_covering_tombstone_seq, clock); &max_covering_tombstone_seq, clock);
s = table_reader->Get(read_options, key, &get_context, nullptr); s = table_reader->Get(read_options, key, &get_context, nullptr);

2
table/table_test.cc
View File

@ -1412,7 +1412,6 @@ TEST_P(BlockBasedTableTest, BasicBlockBasedTableProperties) {
ImmutableCFOptions ioptions(options); ImmutableCFOptions ioptions(options);
MutableCFOptions moptions(options); MutableCFOptions moptions(options);
ioptions.statistics = options.statistics.get();
c.Finish(options, ioptions, moptions, table_options, c.Finish(options, ioptions, moptions, table_options,
GetPlainInternalComparator(options.comparator), &keys, &kvmap); GetPlainInternalComparator(options.comparator), &keys, &kvmap);
ASSERT_EQ(options.statistics->getTickerCount(NUMBER_BLOCK_NOT_COMPRESSED), 0); ASSERT_EQ(options.statistics->getTickerCount(NUMBER_BLOCK_NOT_COMPRESSED), 0);
@ -1461,7 +1460,6 @@ uint64_t BlockBasedTableTest::IndexUncompressedHelper(bool compressed) {
ImmutableCFOptions ioptions(options); ImmutableCFOptions ioptions(options);
MutableCFOptions moptions(options); MutableCFOptions moptions(options);
ioptions.statistics = options.statistics.get();
c.Finish(options, ioptions, moptions, table_options, c.Finish(options, ioptions, moptions, table_options,
GetPlainInternalComparator(options.comparator), &keys, &kvmap); GetPlainInternalComparator(options.comparator), &keys, &kvmap);
c.ResetTableReader(); c.ResetTableReader();

2
util/filter_bench.cc
View File

@ -282,7 +282,7 @@ struct FilterBench : public MockBlockBasedTableTester {
for (uint32_t i = 0; i < FLAGS_batch_size; ++i) { for (uint32_t i = 0; i < FLAGS_batch_size; ++i) {
kms_.emplace_back(FLAGS_key_size < 8 ? 8 : FLAGS_key_size); kms_.emplace_back(FLAGS_key_size < 8 ? 8 : FLAGS_key_size);
} }
ioptions_.info_log = &stderr_logger_; ioptions_.logger = &stderr_logger_;
table_options_.optimize_filters_for_memory = table_options_.optimize_filters_for_memory =
FLAGS_optimize_filters_for_memory; FLAGS_optimize_filters_for_memory;
} }