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

Change the log level of DB start-up log from Warn to Header.

Browse Source 
Summary: Change the log level of DB start-up log from Warn to Header.

Test Plan: db_bench and observe the LOG header

Reviewers: igor, anthony, IslamAbdelRahman, sdong

Reviewed By: sdong

Subscribers: dhruba, leveldb

Differential Revision: https://reviews.facebook.net/D47067
This commit is contained in:
Yueh-Hsuan Chiang 2015-09-16 11:31:45 -07:00
parent 9566342d28
commit f21c7415a7
3 changed files with 122 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
db/db_impl.cc
View File

@ -4650,11 +4650,10 @@ void DumpRocksDBBuildVersion(Logger * log) {
#if !defined(IOS_CROSS_COMPILE) #if !defined(IOS_CROSS_COMPILE)
// if we compile with Xcode, we don't run build_detect_vesion, so we don't // if we compile with Xcode, we don't run build_detect_vesion, so we don't
// generate util/build_version.cc // generate util/build_version.cc
Warn(log, Header(log, "RocksDB version: %d.%d.%d\n", ROCKSDB_MAJOR, ROCKSDB_MINOR,
"RocksDB version: %d.%d.%d\n", ROCKSDB_MAJOR, ROCKSDB_MINOR, ROCKSDB_PATCH);
ROCKSDB_PATCH); Header(log, "Git sha %s", rocksdb_build_git_sha);
Warn(log, "Git sha %s", rocksdb_build_git_sha); Header(log, "Compile date %s", rocksdb_build_compile_date);
Warn(log, "Compile date %s", rocksdb_build_compile_date);
#endif #endif
} }

24
util/db_info_dumper.cc
View File

@ -34,7 +34,7 @@ void DumpDBFileSummary(const DBOptions& options, const std::string& dbname) {
uint64_t file_size; uint64_t file_size;
std::string file_info, wal_info; std::string file_info, wal_info;
Warn(options.info_log, "DB SUMMARY\n"); Header(options.info_log, "DB SUMMARY\n");
// Get files in dbname dir // Get files in dbname dir
if (!env->GetChildren(dbname, &files).ok()) { if (!env->GetChildren(dbname, &files).ok()) {
Error(options.info_log, Error(options.info_log,
@ -47,18 +47,15 @@ void DumpDBFileSummary(const DBOptions& options, const std::string& dbname) {
} }
switch (type) { switch (type) {
case kCurrentFile: case kCurrentFile:
Warn(options.info_log, Header(options.info_log, "CURRENT file: %s\n", file.c_str());
"CURRENT file: %s\n", file.c_str());
break; break;
case kIdentityFile: case kIdentityFile:
Warn(options.info_log, Header(options.info_log, "IDENTITY file: %s\n", file.c_str());
"IDENTITY file: %s\n", file.c_str());
break; break;
case kDescriptorFile: case kDescriptorFile:
env->GetFileSize(dbname + "/" + file, &file_size); env->GetFileSize(dbname + "/" + file, &file_size);
Warn(options.info_log, Header(options.info_log, "MANIFEST file: %s size: %" PRIu64 " Bytes\n",
"MANIFEST file: %s size: %" PRIu64 " Bytes\n", file.c_str(), file_size);
file.c_str(), file_size);
break; break;
case kLogFile: case kLogFile:
env->GetFileSize(dbname + "/" + file, &file_size); env->GetFileSize(dbname + "/" + file, &file_size);
@ -95,9 +92,9 @@ void DumpDBFileSummary(const DBOptions& options, const std::string& dbname) {
} }
} }
} }
Warn(options.info_log, Header(options.info_log,
"SST files in %s dir, Total Num: %" PRIu64 ", files: %s\n", "SST files in %s dir, Total Num: %" PRIu64 ", files: %s\n",
db_path.path.c_str(), file_num, file_info.c_str()); db_path.path.c_str(), file_num, file_info.c_str());
file_num = 0; file_num = 0;
file_info.clear(); file_info.clear();
} }
@ -123,8 +120,7 @@ void DumpDBFileSummary(const DBOptions& options, const std::string& dbname) {
} }
} }
} }
Warn(options.info_log, Header(options.info_log, "Write Ahead Log file in %s: %s\n",
"Write Ahead Log file in %s: %s\n", options.wal_dir.c_str(), wal_info.c_str());
options.wal_dir.c_str(), wal_info.c_str());
} }
} // namespace rocksdb } // namespace rocksdb

212
util/options.cc
View File

@ -314,229 +314,233 @@ static const char* const access_hints[] = {
}; };
void DBOptions::Dump(Logger* log) const { void DBOptions::Dump(Logger* log) const {
Warn(log, " Options.error_if_exists: %d", error_if_exists); Header(log, " Options.error_if_exists: %d", error_if_exists);
Warn(log, " Options.create_if_missing: %d", create_if_missing); Header(log, " Options.create_if_missing: %d", create_if_missing);
Warn(log, " Options.paranoid_checks: %d", paranoid_checks); Header(log, " Options.paranoid_checks: %d", paranoid_checks);
Warn(log, " Options.env: %p", env); Header(log, " Options.env: %p", env);
Warn(log, " Options.info_log: %p", info_log.get()); Header(log, " Options.info_log: %p", info_log.get());
Warn(log, " Options.max_open_files: %d", max_open_files); Header(log, " Options.max_open_files: %d", max_open_files);
Warn(log, "Options.max_file_opening_threads: %d", max_file_opening_threads); Header(log,
Warn(log, " Options.max_total_wal_size: %" PRIu64, max_total_wal_size); "Options.max_file_opening_threads: %d", max_file_opening_threads);
Warn(log, " Options.disableDataSync: %d", disableDataSync); Header(log,
Warn(log, " Options.use_fsync: %d", use_fsync); " Options.max_total_wal_size: %" PRIu64, max_total_wal_size);
Warn(log, " Options.max_log_file_size: %" ROCKSDB_PRIszt, Header(log, " Options.disableDataSync: %d", disableDataSync);
Header(log, " Options.use_fsync: %d", use_fsync);
Header(log, " Options.max_log_file_size: %" ROCKSDB_PRIszt,
max_log_file_size); max_log_file_size);
Warn(log, "Options.max_manifest_file_size: %" PRIu64, Header(log, "Options.max_manifest_file_size: %" PRIu64,
max_manifest_file_size); max_manifest_file_size);
Warn(log, " Options.log_file_time_to_roll: %" ROCKSDB_PRIszt, Header(log, " Options.log_file_time_to_roll: %" ROCKSDB_PRIszt,
log_file_time_to_roll); log_file_time_to_roll);
Warn(log, " Options.keep_log_file_num: %" ROCKSDB_PRIszt, Header(log, " Options.keep_log_file_num: %" ROCKSDB_PRIszt,
keep_log_file_num); keep_log_file_num);
Warn(log, " Options.allow_os_buffer: %d", allow_os_buffer); Header(log, " Options.allow_os_buffer: %d", allow_os_buffer);
Warn(log, " Options.allow_mmap_reads: %d", allow_mmap_reads); Header(log, " Options.allow_mmap_reads: %d", allow_mmap_reads);
Warn(log, " Options.allow_mmap_writes: %d", allow_mmap_writes); Header(log, " Options.allow_mmap_writes: %d", allow_mmap_writes);
Warn(log, " Options.create_missing_column_families: %d", Header(log, " Options.create_missing_column_families: %d",
create_missing_column_families); create_missing_column_families);
Warn(log, " Options.db_log_dir: %s", Header(log, " Options.db_log_dir: %s",
db_log_dir.c_str()); db_log_dir.c_str());
Warn(log, " Options.wal_dir: %s", Header(log, " Options.wal_dir: %s",
wal_dir.c_str()); wal_dir.c_str());
Warn(log, " Options.table_cache_numshardbits: %d", Header(log, " Options.table_cache_numshardbits: %d",
table_cache_numshardbits); table_cache_numshardbits);
Warn(log, " Options.delete_obsolete_files_period_micros: %" PRIu64, Header(log, " Options.delete_obsolete_files_period_micros: %" PRIu64,
delete_obsolete_files_period_micros); delete_obsolete_files_period_micros);
Warn(log, " Options.max_background_compactions: %d", Header(log, " Options.max_background_compactions: %d",
max_background_compactions); max_background_compactions);
Warn(log, " Options.max_subcompactions: %" PRIu32, Header(log, " Options.max_subcompactions: %" PRIu32,
max_subcompactions); max_subcompactions);
Warn(log, " Options.max_background_flushes: %d", Header(log, " Options.max_background_flushes: %d",
max_background_flushes); max_background_flushes);
Warn(log, " Options.WAL_ttl_seconds: %" PRIu64, Header(log, " Options.WAL_ttl_seconds: %" PRIu64,
WAL_ttl_seconds); WAL_ttl_seconds);
Warn(log, " Options.WAL_size_limit_MB: %" PRIu64, Header(log, " Options.WAL_size_limit_MB: %" PRIu64,
WAL_size_limit_MB); WAL_size_limit_MB);
Warn(log, Header(log,
" Options.manifest_preallocation_size: %" ROCKSDB_PRIszt, " Options.manifest_preallocation_size: %" ROCKSDB_PRIszt,
manifest_preallocation_size); manifest_preallocation_size);
Warn(log, " Options.allow_os_buffer: %d", Header(log, " Options.allow_os_buffer: %d",
allow_os_buffer); allow_os_buffer);
Warn(log, " Options.allow_mmap_reads: %d", Header(log, " Options.allow_mmap_reads: %d",
allow_mmap_reads); allow_mmap_reads);
Warn(log, " Options.allow_mmap_writes: %d", Header(log, " Options.allow_mmap_writes: %d",
allow_mmap_writes); allow_mmap_writes);
Warn(log, " Options.is_fd_close_on_exec: %d", Header(log, " Options.is_fd_close_on_exec: %d",
is_fd_close_on_exec); is_fd_close_on_exec);
Warn(log, " Options.stats_dump_period_sec: %u", Header(log, " Options.stats_dump_period_sec: %u",
stats_dump_period_sec); stats_dump_period_sec);
Warn(log, " Options.advise_random_on_open: %d", Header(log, " Options.advise_random_on_open: %d",
advise_random_on_open); advise_random_on_open);
Warn(log, Header(log,
" Options.db_write_buffer_size: %" ROCKSDB_PRIszt " Options.db_write_buffer_size: %" ROCKSDB_PRIszt
"d", "d",
db_write_buffer_size); db_write_buffer_size);
Warn(log, " Options.access_hint_on_compaction_start: %s", Header(log, " Options.access_hint_on_compaction_start: %s",
access_hints[access_hint_on_compaction_start]); access_hints[access_hint_on_compaction_start]);
Warn(log, " Options.new_table_reader_for_compaction_inputs: %d", Header(log, " Options.new_table_reader_for_compaction_inputs: %d",
new_table_reader_for_compaction_inputs); new_table_reader_for_compaction_inputs);
Warn(log, Header(log,
" Options.compaction_readahead_size: %" ROCKSDB_PRIszt " Options.compaction_readahead_size: %" ROCKSDB_PRIszt
"d", "d",
compaction_readahead_size); compaction_readahead_size);
Warn(log, " Options.use_adaptive_mutex: %d", Header(log, " Options.use_adaptive_mutex: %d",
use_adaptive_mutex); use_adaptive_mutex);
Warn(log, " Options.rate_limiter: %p", Header(log, " Options.rate_limiter: %p",
rate_limiter.get()); rate_limiter.get());
Warn(log, " Options.delete_scheduler.rate_bytes_per_sec: %" PRIi64, Header(log, " Options.delete_scheduler.rate_bytes_per_sec: %" PRIi64,
delete_scheduler ? delete_scheduler->GetRateBytesPerSecond() : 0); delete_scheduler ? delete_scheduler->GetRateBytesPerSecond() : 0);
Warn(log, " Options.bytes_per_sync: %" PRIu64, Header(log, " Options.bytes_per_sync: %" PRIu64,
bytes_per_sync); bytes_per_sync);
Warn(log, " Options.wal_bytes_per_sync: %" PRIu64, Header(log, " Options.wal_bytes_per_sync: %" PRIu64,
wal_bytes_per_sync); wal_bytes_per_sync);
Warn(log, " Options.wal_recovery_mode: %d", Header(log, " Options.wal_recovery_mode: %d",
wal_recovery_mode); wal_recovery_mode);
Warn(log, " Options.enable_thread_tracking: %d", Header(log, " Options.enable_thread_tracking: %d",
enable_thread_tracking); enable_thread_tracking);
if (row_cache) { if (row_cache) {
Warn(log, " Options.row_cache: %" PRIu64, Header(log, " Options.row_cache: %" PRIu64,
row_cache->GetCapacity()); row_cache->GetCapacity());
} else { } else {
Warn(log, " Options.row_cache: None"); Header(log, " Options.row_cache: None");
} }
} // DBOptions::Dump } // DBOptions::Dump
void ColumnFamilyOptions::Dump(Logger* log) const { void ColumnFamilyOptions::Dump(Logger* log) const {
Warn(log, " Options.comparator: %s", comparator->Name()); Header(log, " Options.comparator: %s", comparator->Name());
Warn(log, " Options.merge_operator: %s", Header(log, " Options.merge_operator: %s",
merge_operator ? merge_operator->Name() : "None"); merge_operator ? merge_operator->Name() : "None");
Warn(log, " Options.compaction_filter: %s", Header(log, " Options.compaction_filter: %s",
compaction_filter ? compaction_filter->Name() : "None"); compaction_filter ? compaction_filter->Name() : "None");
Warn(log, " Options.compaction_filter_factory: %s", Header(log, " Options.compaction_filter_factory: %s",
compaction_filter_factory ? compaction_filter_factory->Name() : "None"); compaction_filter_factory ? compaction_filter_factory->Name() : "None");
Warn(log, " Options.memtable_factory: %s", memtable_factory->Name()); Header(log, " Options.memtable_factory: %s", memtable_factory->Name());
Warn(log, " Options.table_factory: %s", table_factory->Name()); Header(log, " Options.table_factory: %s", table_factory->Name());
Warn(log, " table_factory options: %s", Header(log, " table_factory options: %s",
table_factory->GetPrintableTableOptions().c_str()); table_factory->GetPrintableTableOptions().c_str());
Warn(log, " Options.write_buffer_size: %" ROCKSDB_PRIszt, Header(log, " Options.write_buffer_size: %" ROCKSDB_PRIszt,
write_buffer_size); write_buffer_size);
Warn(log, " Options.max_write_buffer_number: %d", max_write_buffer_number); Header(log, " Options.max_write_buffer_number: %d", max_write_buffer_number);
if (!compression_per_level.empty()) { if (!compression_per_level.empty()) {
for (unsigned int i = 0; i < compression_per_level.size(); i++) { for (unsigned int i = 0; i < compression_per_level.size(); i++) {
Warn(log, " Options.compression[%d]: %s", i, Header(log, " Options.compression[%d]: %s", i,
CompressionTypeToString(compression_per_level[i]).c_str()); CompressionTypeToString(compression_per_level[i]).c_str());
} }
} else { } else {
Warn(log, " Options.compression: %s", Header(log, " Options.compression: %s",
CompressionTypeToString(compression).c_str()); CompressionTypeToString(compression).c_str());
} }
Warn(log, " Options.prefix_extractor: %s", Header(log, " Options.prefix_extractor: %s",
prefix_extractor == nullptr ? "nullptr" : prefix_extractor->Name()); prefix_extractor == nullptr ? "nullptr" : prefix_extractor->Name());
Warn(log, " Options.num_levels: %d", num_levels); Header(log, " Options.num_levels: %d", num_levels);
Warn(log, " Options.min_write_buffer_number_to_merge: %d", Header(log, " Options.min_write_buffer_number_to_merge: %d",
min_write_buffer_number_to_merge); min_write_buffer_number_to_merge);
Warn(log, " Options.max_write_buffer_number_to_maintain: %d", Header(log, " Options.max_write_buffer_number_to_maintain: %d",
max_write_buffer_number_to_maintain); max_write_buffer_number_to_maintain);
Warn(log, " Options.compression_opts.window_bits: %d", Header(log, " Options.compression_opts.window_bits: %d",
compression_opts.window_bits); compression_opts.window_bits);
Warn(log, " Options.compression_opts.level: %d", Header(log, " Options.compression_opts.level: %d",
compression_opts.level); compression_opts.level);
Warn(log, " Options.compression_opts.strategy: %d", Header(log, " Options.compression_opts.strategy: %d",
compression_opts.strategy); compression_opts.strategy);
Warn(log, " Options.level0_file_num_compaction_trigger: %d", Header(log, " Options.level0_file_num_compaction_trigger: %d",
level0_file_num_compaction_trigger); level0_file_num_compaction_trigger);
Warn(log, " Options.level0_slowdown_writes_trigger: %d", Header(log, " Options.level0_slowdown_writes_trigger: %d",
level0_slowdown_writes_trigger); level0_slowdown_writes_trigger);
Warn(log, " Options.level0_stop_writes_trigger: %d", Header(log, " Options.level0_stop_writes_trigger: %d",
level0_stop_writes_trigger); level0_stop_writes_trigger);
Warn(log, " Options.target_file_size_base: %" PRIu64, Header(log, " Options.target_file_size_base: %" PRIu64,
target_file_size_base); target_file_size_base);
Warn(log, " Options.target_file_size_multiplier: %d", Header(log, " Options.target_file_size_multiplier: %d",
target_file_size_multiplier); target_file_size_multiplier);
Warn(log, " Options.max_bytes_for_level_base: %" PRIu64, Header(log, " Options.max_bytes_for_level_base: %" PRIu64,
max_bytes_for_level_base); max_bytes_for_level_base);
Warn(log, "Options.level_compaction_dynamic_level_bytes: %d", Header(log, "Options.level_compaction_dynamic_level_bytes: %d",
level_compaction_dynamic_level_bytes); level_compaction_dynamic_level_bytes);
Warn(log, " Options.max_bytes_for_level_multiplier: %d", Header(log, " Options.max_bytes_for_level_multiplier: %d",
max_bytes_for_level_multiplier); max_bytes_for_level_multiplier);
for (size_t i = 0; i < max_bytes_for_level_multiplier_additional.size(); for (size_t i = 0; i < max_bytes_for_level_multiplier_additional.size();
i++) { i++) {
Warn(log, "Options.max_bytes_for_level_multiplier_addtl[%" ROCKSDB_PRIszt Header(log,
"Options.max_bytes_for_level_multiplier_addtl[%" ROCKSDB_PRIszt
"]: %d", "]: %d",
i, max_bytes_for_level_multiplier_additional[i]); i, max_bytes_for_level_multiplier_additional[i]);
} }
Warn(log, " Options.max_sequential_skip_in_iterations: %" PRIu64, Header(log, " Options.max_sequential_skip_in_iterations: %" PRIu64,
max_sequential_skip_in_iterations); max_sequential_skip_in_iterations);
Warn(log, " Options.expanded_compaction_factor: %d", Header(log, " Options.expanded_compaction_factor: %d",
expanded_compaction_factor); expanded_compaction_factor);
Warn(log, " Options.source_compaction_factor: %d", Header(log, " Options.source_compaction_factor: %d",
source_compaction_factor); source_compaction_factor);
Warn(log, " Options.max_grandparent_overlap_factor: %d", Header(log, " Options.max_grandparent_overlap_factor: %d",
max_grandparent_overlap_factor); max_grandparent_overlap_factor);
Warn(log, Header(log,
" Options.arena_block_size: %" ROCKSDB_PRIszt, " Options.arena_block_size: %" ROCKSDB_PRIszt,
arena_block_size); arena_block_size);
Warn(log, " Options.soft_rate_limit: %.2f", Header(log, " Options.soft_rate_limit: %.2f",
soft_rate_limit); soft_rate_limit);
Warn(log, " Options.hard_pending_compaction_bytes_limit: %" PRIu64, Header(log, " Options.hard_pending_compaction_bytes_limit: %" PRIu64,
hard_pending_compaction_bytes_limit); hard_pending_compaction_bytes_limit);
Warn(log, " Options.rate_limit_delay_max_milliseconds: %u", Header(log, " Options.rate_limit_delay_max_milliseconds: %u",
rate_limit_delay_max_milliseconds); rate_limit_delay_max_milliseconds);
Warn(log, " Options.disable_auto_compactions: %d", Header(log, " Options.disable_auto_compactions: %d",
disable_auto_compactions); disable_auto_compactions);
Warn(log, " Options.filter_deletes: %d", Header(log, " Options.filter_deletes: %d",
filter_deletes); filter_deletes);
Warn(log, " Options.verify_checksums_in_compaction: %d", Header(log, " Options.verify_checksums_in_compaction: %d",
verify_checksums_in_compaction); verify_checksums_in_compaction);
Warn(log, " Options.compaction_style: %d", Header(log, " Options.compaction_style: %d",
compaction_style); compaction_style);
Warn(log, " Options.compaction_options_universal.size_ratio: %u", Header(log, " Options.compaction_options_universal.size_ratio: %u",
compaction_options_universal.size_ratio); compaction_options_universal.size_ratio);
Warn(log, "Options.compaction_options_universal.min_merge_width: %u", Header(log, "Options.compaction_options_universal.min_merge_width: %u",
compaction_options_universal.min_merge_width); compaction_options_universal.min_merge_width);
Warn(log, "Options.compaction_options_universal.max_merge_width: %u", Header(log, "Options.compaction_options_universal.max_merge_width: %u",
compaction_options_universal.max_merge_width); compaction_options_universal.max_merge_width);
Warn(log, "Options.compaction_options_universal." Header(log, "Options.compaction_options_universal."
"max_size_amplification_percent: %u", "max_size_amplification_percent: %u",
compaction_options_universal.max_size_amplification_percent); compaction_options_universal.max_size_amplification_percent);
Warn(log, Header(log,
"Options.compaction_options_universal.compression_size_percent: %d", "Options.compaction_options_universal.compression_size_percent: %d",
compaction_options_universal.compression_size_percent); compaction_options_universal.compression_size_percent);
Warn(log, "Options.compaction_options_fifo.max_table_files_size: %" PRIu64, Header(log,
"Options.compaction_options_fifo.max_table_files_size: %" PRIu64,
compaction_options_fifo.max_table_files_size); compaction_options_fifo.max_table_files_size);
std::string collector_names; std::string collector_names;
for (const auto& collector_factory : table_properties_collector_factories) { for (const auto& collector_factory : table_properties_collector_factories) {
collector_names.append(collector_factory->Name()); collector_names.append(collector_factory->Name());
collector_names.append("; "); collector_names.append("; ");
} }
Warn(log, " Options.table_properties_collectors: %s", Header(log, " Options.table_properties_collectors: %s",
collector_names.c_str()); collector_names.c_str());
Warn(log, " Options.inplace_update_support: %d", Header(log, " Options.inplace_update_support: %d",
inplace_update_support); inplace_update_support);
Warn(log, Header(log,
" Options.inplace_update_num_locks: %" ROCKSDB_PRIszt, " Options.inplace_update_num_locks: %" ROCKSDB_PRIszt,
inplace_update_num_locks); inplace_update_num_locks);
Warn(log, " Options.min_partial_merge_operands: %u", Header(log, " Options.min_partial_merge_operands: %u",
min_partial_merge_operands); min_partial_merge_operands);
// TODO: easier config for bloom (maybe based on avg key/value size) // TODO: easier config for bloom (maybe based on avg key/value size)
Warn(log, " Options.memtable_prefix_bloom_bits: %d", Header(log, " Options.memtable_prefix_bloom_bits: %d",
memtable_prefix_bloom_bits); memtable_prefix_bloom_bits);
Warn(log, " Options.memtable_prefix_bloom_probes: %d", Header(log, " Options.memtable_prefix_bloom_probes: %d",
memtable_prefix_bloom_probes); memtable_prefix_bloom_probes);
Warn(log, Header(log,
" Options.memtable_prefix_bloom_huge_page_tlb_size: %" ROCKSDB_PRIszt, " Options.memtable_prefix_bloom_huge_page_tlb_size: %" ROCKSDB_PRIszt,
memtable_prefix_bloom_huge_page_tlb_size); memtable_prefix_bloom_huge_page_tlb_size);
Warn(log, " Options.bloom_locality: %d", Header(log, " Options.bloom_locality: %d",
bloom_locality); bloom_locality);
Warn(log, Header(log,
" Options.max_successive_merges: %" ROCKSDB_PRIszt, " Options.max_successive_merges: %" ROCKSDB_PRIszt,
max_successive_merges); max_successive_merges);
Warn(log, " Options.optimize_fllters_for_hits: %d", Header(log, " Options.optimize_fllters_for_hits: %d",
optimize_filters_for_hits); optimize_filters_for_hits);
Warn(log, " Options.paranoid_file_checks: %d", Header(log, " Options.paranoid_file_checks: %d",
paranoid_file_checks); paranoid_file_checks);
Warn(log, " Options.compaction_measure_io_stats: %d", Header(log, " Options.compaction_measure_io_stats: %d",
compaction_measure_io_stats); compaction_measure_io_stats);
} // ColumnFamilyOptions::Dump } // ColumnFamilyOptions::Dump