2016-02-10 00:12:00 +01:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2017-07-16 01:03:42 +02:00
|
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
|
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
|
|
|
// (found in the LICENSE.Apache file in the root directory).
|
2014-09-17 21:49:13 +02:00
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
2016-09-02 23:16:31 +02:00
|
|
|
#include <string>
|
2014-10-02 01:19:16 +02:00
|
|
|
#include <vector>
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2016-11-21 21:07:09 +01:00
|
|
|
#include "db/dbformat.h"
|
2017-04-06 04:02:00 +02:00
|
|
|
#include "options/db_options.h"
|
2016-05-17 22:11:56 +02:00
|
|
|
#include "rocksdb/options.h"
|
|
|
|
|
#include "util/compression.h"
|
2014-09-17 21:49:13 +02:00
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
namespace ROCKSDB_NAMESPACE {
|
2014-09-17 21:49:13 +02:00
|
|
|
|
2016-09-02 23:16:31 +02:00
|
|
|
// ImmutableCFOptions is a data struct used by RocksDB internal. It contains a
|
|
|
|
|
// subset of Options that should not be changed during the entire lifetime
|
|
|
|
|
// of DB. Raw pointers defined in this struct do not have ownership to the data
|
2018-11-09 20:17:34 +01:00
|
|
|
// they point to. Options contains std::shared_ptr to these data.
|
2016-09-02 23:16:31 +02:00
|
|
|
struct ImmutableCFOptions {
|
2021-04-23 05:42:50 +02:00
|
|
|
public:
|
2020-09-15 01:59:00 +02:00
|
|
|
static const char* kName() { return "ImmutableCFOptions"; }
|
2021-04-23 05:42:50 +02:00
|
|
|
explicit ImmutableCFOptions();
|
2016-09-02 23:16:31 +02:00
|
|
|
explicit ImmutableCFOptions(const Options& options);
|
|
|
|
|
|
2016-09-24 01:34:04 +02:00
|
|
|
ImmutableCFOptions(const ImmutableDBOptions& db_options,
|
|
|
|
|
const ColumnFamilyOptions& cf_options);
|
|
|
|
|
|
2016-09-02 23:16:31 +02:00
|
|
|
CompactionStyle compaction_style;
|
|
|
|
|
|
2016-09-14 06:11:59 +02:00
|
|
|
CompactionPri compaction_pri;
|
|
|
|
|
|
2016-10-21 20:31:42 +02:00
|
|
|
const Comparator* user_comparator;
|
2021-04-23 05:42:50 +02:00
|
|
|
InternalKeyComparator internal_comparator; // Only in Immutable
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<MergeOperator> merge_operator;
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
const CompactionFilter* compaction_filter;
|
|
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<CompactionFilterFactory> compaction_filter_factory;
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2016-09-24 01:34:04 +02:00
|
|
|
int min_write_buffer_number_to_merge;
|
|
|
|
|
|
|
|
|
|
int max_write_buffer_number_to_maintain;
|
|
|
|
|
|
Refactor trimming logic for immutable memtables (#5022)
Summary:
MyRocks currently sets `max_write_buffer_number_to_maintain` in order to maintain enough history for transaction conflict checking. The effectiveness of this approach depends on the size of memtables. When memtables are small, it may not keep enough history; when memtables are large, this may consume too much memory.
We are proposing a new way to configure memtable list history: by limiting the memory usage of immutable memtables. The new option is `max_write_buffer_size_to_maintain` and it will take precedence over the old `max_write_buffer_number_to_maintain` if they are both set to non-zero values. The new option accounts for the total memory usage of flushed immutable memtables and mutable memtable. When the total usage exceeds the limit, RocksDB may start dropping immutable memtables (which is also called trimming history), starting from the oldest one.
The semantics of the old option actually works both as an upper bound and lower bound. History trimming will start if number of immutable memtables exceeds the limit, but it will never go below (limit-1) due to history trimming.
In order the mimic the behavior with the new option, history trimming will stop if dropping the next immutable memtable causes the total memory usage go below the size limit. For example, assuming the size limit is set to 64MB, and there are 3 immutable memtables with sizes of 20, 30, 30. Although the total memory usage is 80MB > 64MB, dropping the oldest memtable will reduce the memory usage to 60MB < 64MB, so in this case no memtable will be dropped.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5022
Differential Revision: D14394062
Pulled By: miasantreble
fbshipit-source-id: 60457a509c6af89d0993f988c9b5c2aa9e45f5c5
2019-08-23 22:54:09 +02:00
|
|
|
int64_t max_write_buffer_size_to_maintain;
|
|
|
|
|
|
2016-09-02 23:16:31 +02:00
|
|
|
bool inplace_update_support;
|
|
|
|
|
|
|
|
|
|
UpdateStatus (*inplace_callback)(char* existing_value,
|
|
|
|
|
uint32_t* existing_value_size,
|
|
|
|
|
Slice delta_value,
|
|
|
|
|
std::string* merged_value);
|
|
|
|
|
|
2021-04-26 21:43:02 +02:00
|
|
|
Logger* logger; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-26 21:43:02 +02:00
|
|
|
Statistics* stats; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<RateLimiter> rate_limiter; // ImmutableDBOptions
|
2017-06-13 23:51:22 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
InfoLogLevel info_log_level; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
Env* env; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
FileSystem* fs; // ImmutableDBOptions
|
Introduce a new storage specific Env API (#5761)
Summary:
The current Env API encompasses both storage/file operations, as well as OS related operations. Most of the APIs return a Status, which does not have enough metadata about an error, such as whether its retry-able or not, scope (i.e fault domain) of the error etc., that may be required in order to properly handle a storage error. The file APIs also do not provide enough control over the IO SLA, such as timeout, prioritization, hinting about placement and redundancy etc.
This PR separates out the file/storage APIs from Env into a new FileSystem class. The APIs are updated to return an IOStatus with metadata about the error, as well as to take an IOOptions structure as input in order to allow more control over the IO.
The user can set both ```options.env``` and ```options.file_system``` to specify that RocksDB should use the former for OS related operations and the latter for storage operations. Internally, a ```CompositeEnvWrapper``` has been introduced that inherits from ```Env``` and redirects individual methods to either an ```Env``` implementation or the ```FileSystem``` as appropriate. When options are sanitized during ```DB::Open```, ```options.env``` is replaced with a newly allocated ```CompositeEnvWrapper``` instance if both env and file_system have been specified. This way, the rest of the RocksDB code can continue to function as before.
This PR also ports PosixEnv to the new API by splitting it into two - PosixEnv and PosixFileSystem. PosixEnv is defined as a sub-class of CompositeEnvWrapper, and threading/time functions are overridden with Posix specific implementations in order to avoid an extra level of indirection.
The ```CompositeEnvWrapper``` translates ```IOStatus``` return code to ```Status```, and sets the severity to ```kSoftError``` if the io_status is retryable. The error handling code in RocksDB can then recover the DB automatically.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5761
Differential Revision: D18868376
Pulled By: anand1976
fbshipit-source-id: 39efe18a162ea746fabac6360ff529baba48486f
2019-12-13 23:47:08 +01:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
SystemClock* clock; // ImmutableDBOptions
|
2021-03-15 12:32:24 +01:00
|
|
|
|
2016-09-02 23:16:31 +02:00
|
|
|
// Allow the OS to mmap file for reading sst tables. Default: false
|
2021-04-23 05:42:50 +02:00
|
|
|
bool allow_mmap_reads; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
// Allow the OS to mmap file for writing. Default: false
|
2021-04-23 05:42:50 +02:00
|
|
|
bool allow_mmap_writes; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::vector<DbPath> db_paths; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<MemTableRepFactory> memtable_factory;
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<TableFactory> table_factory;
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
Options::TablePropertiesCollectorFactories
|
|
|
|
|
table_properties_collector_factories;
|
|
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool advise_random_on_open; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
// This options is required by PlainTableReader. May need to move it
|
2017-08-17 06:45:32 +02:00
|
|
|
// to PlainTableOptions just like bloom_bits_per_key
|
2016-09-02 23:16:31 +02:00
|
|
|
uint32_t bloom_locality;
|
|
|
|
|
|
|
|
|
|
bool purge_redundant_kvs_while_flush;
|
|
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool use_fsync; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
std::vector<CompressionType> compression_per_level;
|
|
|
|
|
|
|
|
|
|
bool level_compaction_dynamic_level_bytes;
|
|
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
Options::AccessHint access_hint_on_compaction_start; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool new_table_reader_for_compaction_inputs; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
|
|
|
|
int num_levels;
|
|
|
|
|
|
|
|
|
|
bool optimize_filters_for_hits;
|
|
|
|
|
|
2016-10-08 02:21:45 +02:00
|
|
|
bool force_consistency_checks;
|
|
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool allow_ingest_behind; // ImmutableDBOptions
|
2017-05-17 20:32:26 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool preserve_deletes; // ImmutableDBOptions
|
Added support for differential snapshots
Summary:
The motivation for this PR is to add to RocksDB support for differential (incremental) snapshots, as snapshot of the DB changes between two points in time (one can think of it as diff between to sequence numbers, or the diff D which can be thought of as an SST file or just set of KVs that can be applied to sequence number S1 to get the database to the state at sequence number S2).
This feature would be useful for various distributed storages layers built on top of RocksDB, as it should help reduce resources (time and network bandwidth) needed to recover and rebuilt DB instances as replicas in the context of distributed storages.
From the API standpoint that would like client app requesting iterator between (start seqnum) and current DB state, and reading the "diff".
This is a very draft PR for initial review in the discussion on the approach, i'm going to rework some parts and keep updating the PR.
For now, what's done here according to initial discussions:
Preserving deletes:
- We want to be able to optionally preserve recent deletes for some defined period of time, so that if a delete came in recently and might need to be included in the next incremental snapshot it would't get dropped by a compaction. This is done by adding new param to Options (preserve deletes flag) and new variable to DB Impl where we keep track of the sequence number after which we don't want to drop tombstones, even if they are otherwise eligible for deletion.
- I also added a new API call for clients to be able to advance this cutoff seqnum after which we drop deletes; i assume it's more flexible to let clients control this, since otherwise we'd need to keep some kind of timestamp < -- > seqnum mapping inside the DB, which sounds messy and painful to support. Clients could make use of it by periodically calling GetLatestSequenceNumber(), noting the timestamp, doing some calculation and figuring out by how much we need to advance the cutoff seqnum.
- Compaction codepath in compaction_iterator.cc has been modified to avoid dropping tombstones with seqnum > cutoff seqnum.
Iterator changes:
- couple params added to ReadOptions, to optionally allow client to request internal keys instead of user keys (so that client can get the latest value of a key, be it delete marker or a put), as well as min timestamp and min seqnum.
TableCache changes:
- I modified table_cache code to be able to quickly exclude SST files from iterators heep if creation_time on the file is less then iter_start_ts as passed in ReadOptions. That would help a lot in some DB settings (like reading very recent data only or using FIFO compactions), but not so much for universal compaction with more or less long iterator time span.
What's left:
- Still looking at how to best plug that inside DBIter codepath. So far it seems that FindNextUserKeyInternal only parses values as UserKeys, and iter->key() call generally returns user key. Can we add new API to DBIter as internal_key(), and modify this internal method to optionally set saved_key_ to point to the full internal key? I don't need to store actual seqnum there, but I do need to store type.
Closes https://github.com/facebook/rocksdb/pull/2999
Differential Revision: D6175602
Pulled By: mikhail-antonov
fbshipit-source-id: c779a6696ee2d574d86c69cec866a3ae095aa900
2017-11-02 02:43:29 +01:00
|
|
|
|
2018-04-11 00:47:54 +02:00
|
|
|
// A vector of EventListeners which callback functions will be called
|
2016-09-02 23:16:31 +02:00
|
|
|
// when specific RocksDB event happens.
|
2021-04-23 05:42:50 +02:00
|
|
|
std::vector<std::shared_ptr<EventListener>> listeners; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<Cache> row_cache; // ImmutableDBOptions
|
2016-09-14 06:11:59 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<const SliceTransform>
|
|
|
|
|
memtable_insert_with_hint_prefix_extractor;
|
2018-04-03 06:57:28 +02:00
|
|
|
|
2018-04-06 04:49:06 +02:00
|
|
|
std::vector<DbPath> cf_paths;
|
Concurrent task limiter for compaction thread control (#4332)
Summary:
The PR is targeting to resolve the issue of:
https://github.com/facebook/rocksdb/issues/3972#issue-330771918
We have a rocksdb created with leveled-compaction with multiple column families (CFs), some of CFs are using HDD to store big and less frequently accessed data and others are using SSD.
When there are continuously write traffics going on to all CFs, the compaction thread pool is mostly occupied by those slow HDD compactions, which blocks fully utilize SSD bandwidth.
Since atomic write and transaction is needed across CFs, so splitting it to multiple rocksdb instance is not an option for us.
With the compaction thread control, we got 30%+ HDD write throughput gain, and also a lot smooth SSD write since less write stall happening.
ConcurrentTaskLimiter can be shared with multi-CFs across rocksdb instances, so the feature does not only work for multi-CFs scenarios, but also for multi-rocksdbs scenarios, who need disk IO resource control per tenant.
The usage is straight forward:
e.g.:
//
// Enable compaction thread limiter thru ColumnFamilyOptions
//
std::shared_ptr<ConcurrentTaskLimiter> ctl(NewConcurrentTaskLimiter("foo_limiter", 4));
Options options;
ColumnFamilyOptions cf_opt(options);
cf_opt.compaction_thread_limiter = ctl;
...
//
// Compaction thread limiter can be tuned or disabled on-the-fly
//
ctl->SetMaxOutstandingTask(12); // enlarge to 12 tasks
...
ctl->ResetMaxOutstandingTask(); // disable (bypass) thread limiter
ctl->SetMaxOutstandingTask(-1); // Same as above
...
ctl->SetMaxOutstandingTask(0); // full throttle (0 task)
//
// Sharing compaction thread limiter among CFs (to resolve multiple storage perf issue)
//
std::shared_ptr<ConcurrentTaskLimiter> ctl_ssd(NewConcurrentTaskLimiter("ssd_limiter", 8));
std::shared_ptr<ConcurrentTaskLimiter> ctl_hdd(NewConcurrentTaskLimiter("hdd_limiter", 4));
Options options;
ColumnFamilyOptions cf_opt_ssd1(options);
ColumnFamilyOptions cf_opt_ssd2(options);
ColumnFamilyOptions cf_opt_hdd1(options);
ColumnFamilyOptions cf_opt_hdd2(options);
ColumnFamilyOptions cf_opt_hdd3(options);
// SSD CFs
cf_opt_ssd1.compaction_thread_limiter = ctl_ssd;
cf_opt_ssd2.compaction_thread_limiter = ctl_ssd;
// HDD CFs
cf_opt_hdd1.compaction_thread_limiter = ctl_hdd;
cf_opt_hdd2.compaction_thread_limiter = ctl_hdd;
cf_opt_hdd3.compaction_thread_limiter = ctl_hdd;
...
//
// The limiter is disabled by default (or set to nullptr explicitly)
//
Options options;
ColumnFamilyOptions cf_opt(options);
cf_opt.compaction_thread_limiter = nullptr;
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4332
Differential Revision: D13226590
Pulled By: siying
fbshipit-source-id: 14307aec55b8bd59c8223d04aa6db3c03d1b0c1d
2018-12-13 22:16:04 +01:00
|
|
|
|
|
|
|
|
std::shared_ptr<ConcurrentTaskLimiter> compaction_thread_limiter;
|
2020-02-11 00:42:46 +01:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::shared_ptr<FileChecksumGenFactory>
|
|
|
|
|
file_checksum_gen_factory; // ImmutableDBOptions
|
2020-07-24 22:43:14 +02:00
|
|
|
|
|
|
|
|
std::shared_ptr<SstPartitionerFactory> sst_partitioner_factory;
|
2020-09-30 08:16:12 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
bool allow_data_in_errors; // ImmutableDBOptions
|
2020-10-19 20:37:05 +02:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
std::string db_host_id; // ImmutableDBOptions
|
2021-02-11 07:18:33 +01:00
|
|
|
|
2021-04-23 05:42:50 +02:00
|
|
|
FileTypeSet checksum_handoff_file_types; // ImmutableDBOptions
|
2016-09-02 23:16:31 +02:00
|
|
|
};
|
|
|
|
|
|
2014-09-17 21:49:13 +02:00
|
|
|
struct MutableCFOptions {
|
2020-09-15 01:59:00 +02:00
|
|
|
static const char* kName() { return "MutableCFOptions"; }
|
2016-09-14 06:11:59 +02:00
|
|
|
explicit MutableCFOptions(const ColumnFamilyOptions& options)
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
: write_buffer_size(options.write_buffer_size),
|
|
|
|
|
max_write_buffer_number(options.max_write_buffer_number),
|
|
|
|
|
arena_block_size(options.arena_block_size),
|
2016-06-04 02:02:10 +02:00
|
|
|
memtable_prefix_bloom_size_ratio(
|
|
|
|
|
options.memtable_prefix_bloom_size_ratio),
|
2019-02-19 21:12:25 +01:00
|
|
|
memtable_whole_key_filtering(options.memtable_whole_key_filtering),
|
2016-07-27 03:05:30 +02:00
|
|
|
memtable_huge_page_size(options.memtable_huge_page_size),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
max_successive_merges(options.max_successive_merges),
|
|
|
|
|
inplace_update_num_locks(options.inplace_update_num_locks),
|
2018-05-21 23:33:55 +02:00
|
|
|
prefix_extractor(options.prefix_extractor),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
disable_auto_compactions(options.disable_auto_compactions),
|
2015-11-19 03:10:20 +01:00
|
|
|
soft_pending_compaction_bytes_limit(
|
|
|
|
|
options.soft_pending_compaction_bytes_limit),
|
2015-09-11 23:31:23 +02:00
|
|
|
hard_pending_compaction_bytes_limit(
|
|
|
|
|
options.hard_pending_compaction_bytes_limit),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
level0_file_num_compaction_trigger(
|
|
|
|
|
options.level0_file_num_compaction_trigger),
|
|
|
|
|
level0_slowdown_writes_trigger(options.level0_slowdown_writes_trigger),
|
|
|
|
|
level0_stop_writes_trigger(options.level0_stop_writes_trigger),
|
2016-06-17 01:02:52 +02:00
|
|
|
max_compaction_bytes(options.max_compaction_bytes),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
target_file_size_base(options.target_file_size_base),
|
|
|
|
|
target_file_size_multiplier(options.target_file_size_multiplier),
|
|
|
|
|
max_bytes_for_level_base(options.max_bytes_for_level_base),
|
|
|
|
|
max_bytes_for_level_multiplier(options.max_bytes_for_level_multiplier),
|
2018-07-16 23:24:33 +02:00
|
|
|
ttl(options.ttl),
|
Periodic Compactions (#5166)
Summary:
Introducing Periodic Compactions.
This feature allows all the files in a CF to be periodically compacted. It could help in catching any corruptions that could creep into the DB proactively as every file is constantly getting re-compacted. And also, of course, it helps to cleanup data older than certain threshold.
- Introduced a new option `periodic_compaction_time` to control how long a file can live without being compacted in a CF.
- This works across all levels.
- The files are put in the same level after going through the compaction. (Related files in the same level are picked up as `ExpandInputstoCleanCut` is used).
- Compaction filters, if any, are invoked as usual.
- A new table property, `file_creation_time`, is introduced to implement this feature. This property is set to the time at which the SST file was created (and that time is given by the underlying Env/OS).
This feature can be enabled on its own, or in conjunction with `ttl`. It is possible to set a different time threshold for the bottom level when used in conjunction with ttl. Since `ttl` works only on 0 to last but one levels, you could set `ttl` to, say, 1 day, and `periodic_compaction_time` to, say, 7 days. Since `ttl < periodic_compaction_time` all files in last but one levels keep getting picked up based on ttl, and almost never based on periodic_compaction_time. The files in the bottom level get picked up for compaction based on `periodic_compaction_time`.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5166
Differential Revision: D14884441
Pulled By: sagar0
fbshipit-source-id: 408426cbacb409c06386a98632dcf90bfa1bda47
2019-04-11 04:24:25 +02:00
|
|
|
periodic_compaction_seconds(options.periodic_compaction_seconds),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
max_bytes_for_level_multiplier_additional(
|
|
|
|
|
options.max_bytes_for_level_multiplier_additional),
|
2017-10-20 00:19:20 +02:00
|
|
|
compaction_options_fifo(options.compaction_options_fifo),
|
2017-12-11 22:12:12 +01:00
|
|
|
compaction_options_universal(options.compaction_options_universal),
|
2020-08-19 03:31:31 +02:00
|
|
|
enable_blob_files(options.enable_blob_files),
|
|
|
|
|
min_blob_size(options.min_blob_size),
|
|
|
|
|
blob_file_size(options.blob_file_size),
|
|
|
|
|
blob_compression_type(options.blob_compression_type),
|
2020-11-13 03:57:20 +01:00
|
|
|
enable_blob_garbage_collection(options.enable_blob_garbage_collection),
|
|
|
|
|
blob_garbage_collection_age_cutoff(
|
|
|
|
|
options.blob_garbage_collection_age_cutoff),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
max_sequential_skip_in_iterations(
|
|
|
|
|
options.max_sequential_skip_in_iterations),
|
2020-10-01 19:08:52 +02:00
|
|
|
check_flush_compaction_key_order(
|
|
|
|
|
options.check_flush_compaction_key_order),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
paranoid_file_checks(options.paranoid_file_checks),
|
2016-05-17 22:11:56 +02:00
|
|
|
report_bg_io_stats(options.report_bg_io_stats),
|
2019-03-18 20:07:35 +01:00
|
|
|
compression(options.compression),
|
2020-03-31 21:08:41 +02:00
|
|
|
bottommost_compression(options.bottommost_compression),
|
|
|
|
|
compression_opts(options.compression_opts),
|
|
|
|
|
bottommost_compression_opts(options.bottommost_compression_opts),
|
2021-05-03 22:30:00 +02:00
|
|
|
bottommost_temperature(options.bottommost_temperature),
|
2020-07-23 03:31:25 +02:00
|
|
|
sample_for_compression(
|
|
|
|
|
options.sample_for_compression) { // TODO: is 0 fine here?
|
2016-09-14 06:11:59 +02:00
|
|
|
RefreshDerivedOptions(options.num_levels, options.compaction_style);
|
2014-09-17 21:49:13 +02:00
|
|
|
}
|
2016-09-14 06:11:59 +02:00
|
|
|
|
2014-09-17 21:49:13 +02:00
|
|
|
MutableCFOptions()
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
: write_buffer_size(0),
|
|
|
|
|
max_write_buffer_number(0),
|
|
|
|
|
arena_block_size(0),
|
2016-06-04 02:02:10 +02:00
|
|
|
memtable_prefix_bloom_size_ratio(0),
|
2019-02-19 21:12:25 +01:00
|
|
|
memtable_whole_key_filtering(false),
|
2016-07-27 03:05:30 +02:00
|
|
|
memtable_huge_page_size(0),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
max_successive_merges(0),
|
|
|
|
|
inplace_update_num_locks(0),
|
2018-05-21 23:33:55 +02:00
|
|
|
prefix_extractor(nullptr),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
disable_auto_compactions(false),
|
2015-11-19 03:10:20 +01:00
|
|
|
soft_pending_compaction_bytes_limit(0),
|
2015-09-11 23:31:23 +02:00
|
|
|
hard_pending_compaction_bytes_limit(0),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
level0_file_num_compaction_trigger(0),
|
|
|
|
|
level0_slowdown_writes_trigger(0),
|
|
|
|
|
level0_stop_writes_trigger(0),
|
2016-06-17 01:02:52 +02:00
|
|
|
max_compaction_bytes(0),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
target_file_size_base(0),
|
|
|
|
|
target_file_size_multiplier(0),
|
|
|
|
|
max_bytes_for_level_base(0),
|
|
|
|
|
max_bytes_for_level_multiplier(0),
|
2018-07-16 23:24:33 +02:00
|
|
|
ttl(0),
|
Periodic Compactions (#5166)
Summary:
Introducing Periodic Compactions.
This feature allows all the files in a CF to be periodically compacted. It could help in catching any corruptions that could creep into the DB proactively as every file is constantly getting re-compacted. And also, of course, it helps to cleanup data older than certain threshold.
- Introduced a new option `periodic_compaction_time` to control how long a file can live without being compacted in a CF.
- This works across all levels.
- The files are put in the same level after going through the compaction. (Related files in the same level are picked up as `ExpandInputstoCleanCut` is used).
- Compaction filters, if any, are invoked as usual.
- A new table property, `file_creation_time`, is introduced to implement this feature. This property is set to the time at which the SST file was created (and that time is given by the underlying Env/OS).
This feature can be enabled on its own, or in conjunction with `ttl`. It is possible to set a different time threshold for the bottom level when used in conjunction with ttl. Since `ttl` works only on 0 to last but one levels, you could set `ttl` to, say, 1 day, and `periodic_compaction_time` to, say, 7 days. Since `ttl < periodic_compaction_time` all files in last but one levels keep getting picked up based on ttl, and almost never based on periodic_compaction_time. The files in the bottom level get picked up for compaction based on `periodic_compaction_time`.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5166
Differential Revision: D14884441
Pulled By: sagar0
fbshipit-source-id: 408426cbacb409c06386a98632dcf90bfa1bda47
2019-04-11 04:24:25 +02:00
|
|
|
periodic_compaction_seconds(0),
|
2017-10-20 00:19:20 +02:00
|
|
|
compaction_options_fifo(),
|
2020-08-19 03:31:31 +02:00
|
|
|
enable_blob_files(false),
|
|
|
|
|
min_blob_size(0),
|
|
|
|
|
blob_file_size(0),
|
|
|
|
|
blob_compression_type(kNoCompression),
|
2020-11-13 03:57:20 +01:00
|
|
|
enable_blob_garbage_collection(false),
|
|
|
|
|
blob_garbage_collection_age_cutoff(0.0),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
max_sequential_skip_in_iterations(0),
|
2020-10-01 19:08:52 +02:00
|
|
|
check_flush_compaction_key_order(true),
|
Add options.compaction_measure_io_stats to print write I/O stats in compactions
Summary:
Add options.compaction_measure_io_stats to print out / pass to listener accumulated time spent on write calls. Example outputs in info logs:
2015/08/12-16:27:59.463944 7fd428bff700 (Original Log Time 2015/08/12-16:27:59.463922) EVENT_LOG_v1 {"time_micros": 1439422079463897, "job": 6, "event": "compaction_finished", "output_level": 1, "num_output_files": 4, "total_output_size": 6900525, "num_input_records": 111483, "num_output_records": 106877, "file_write_nanos": 15663206, "file_range_sync_nanos": 649588, "file_fsync_nanos": 349614797, "file_prepare_write_nanos": 1505812, "lsm_state": [2, 4, 0, 0, 0, 0, 0]}
Add two more counters in iostats_context.
Also add a parameter of db_bench.
Test Plan: Add a unit test. Also manually verify LOG outputs in db_bench
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44115
2015-08-13 02:24:45 +02:00
|
|
|
paranoid_file_checks(false),
|
2016-05-17 22:11:56 +02:00
|
|
|
report_bg_io_stats(false),
|
2019-03-18 20:07:35 +01:00
|
|
|
compression(Snappy_Supported() ? kSnappyCompression : kNoCompression),
|
2020-03-31 21:08:41 +02:00
|
|
|
bottommost_compression(kDisableCompressionOption),
|
2021-05-03 22:30:00 +02:00
|
|
|
bottommost_temperature(Temperature::kUnknown),
|
2019-03-18 20:07:35 +01:00
|
|
|
sample_for_compression(0) {}
|
2014-09-17 21:49:13 +02:00
|
|
|
|
2018-05-21 23:33:55 +02:00
|
|
|
explicit MutableCFOptions(const Options& options);
|
|
|
|
|
|
2014-10-02 01:19:16 +02:00
|
|
|
// Must be called after any change to MutableCFOptions
|
2016-09-14 06:11:59 +02:00
|
|
|
void RefreshDerivedOptions(int num_levels, CompactionStyle compaction_style);
|
|
|
|
|
|
|
|
|
|
void RefreshDerivedOptions(const ImmutableCFOptions& ioptions) {
|
|
|
|
|
RefreshDerivedOptions(ioptions.num_levels, ioptions.compaction_style);
|
|
|
|
|
}
|
2014-10-02 01:19:16 +02:00
|
|
|
|
2015-03-30 23:04:21 +02:00
|
|
|
int MaxBytesMultiplerAdditional(int level) const {
|
|
|
|
|
if (level >=
|
|
|
|
|
static_cast<int>(max_bytes_for_level_multiplier_additional.size())) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return max_bytes_for_level_multiplier_additional[level];
|
|
|
|
|
}
|
2014-10-02 01:19:16 +02:00
|
|
|
|
2014-10-17 02:22:28 +02:00
|
|
|
void Dump(Logger* log) const;
|
|
|
|
|
|
2014-10-02 01:19:16 +02:00
|
|
|
// Memtable related options
|
2014-09-17 21:49:13 +02:00
|
|
|
size_t write_buffer_size;
|
2014-10-17 01:57:59 +02:00
|
|
|
int max_write_buffer_number;
|
2014-09-17 21:49:13 +02:00
|
|
|
size_t arena_block_size;
|
2016-06-04 02:02:10 +02:00
|
|
|
double memtable_prefix_bloom_size_ratio;
|
2019-02-19 21:12:25 +01:00
|
|
|
bool memtable_whole_key_filtering;
|
2016-07-27 03:05:30 +02:00
|
|
|
size_t memtable_huge_page_size;
|
2014-09-17 21:49:13 +02:00
|
|
|
size_t max_successive_merges;
|
2014-10-27 20:10:13 +01:00
|
|
|
size_t inplace_update_num_locks;
|
2018-05-21 23:33:55 +02:00
|
|
|
std::shared_ptr<const SliceTransform> prefix_extractor;
|
2014-10-02 01:19:16 +02:00
|
|
|
|
|
|
|
|
// Compaction related options
|
2014-10-17 02:14:17 +02:00
|
|
|
bool disable_auto_compactions;
|
2015-11-19 03:10:20 +01:00
|
|
|
uint64_t soft_pending_compaction_bytes_limit;
|
2015-09-11 23:31:23 +02:00
|
|
|
uint64_t hard_pending_compaction_bytes_limit;
|
2014-10-02 01:19:16 +02:00
|
|
|
int level0_file_num_compaction_trigger;
|
|
|
|
|
int level0_slowdown_writes_trigger;
|
|
|
|
|
int level0_stop_writes_trigger;
|
2016-06-17 01:02:52 +02:00
|
|
|
uint64_t max_compaction_bytes;
|
2014-11-11 22:47:22 +01:00
|
|
|
uint64_t target_file_size_base;
|
2014-10-02 01:19:16 +02:00
|
|
|
int target_file_size_multiplier;
|
|
|
|
|
uint64_t max_bytes_for_level_base;
|
2016-11-02 05:05:32 +01:00
|
|
|
double max_bytes_for_level_multiplier;
|
2018-07-16 23:24:33 +02:00
|
|
|
uint64_t ttl;
|
Periodic Compactions (#5166)
Summary:
Introducing Periodic Compactions.
This feature allows all the files in a CF to be periodically compacted. It could help in catching any corruptions that could creep into the DB proactively as every file is constantly getting re-compacted. And also, of course, it helps to cleanup data older than certain threshold.
- Introduced a new option `periodic_compaction_time` to control how long a file can live without being compacted in a CF.
- This works across all levels.
- The files are put in the same level after going through the compaction. (Related files in the same level are picked up as `ExpandInputstoCleanCut` is used).
- Compaction filters, if any, are invoked as usual.
- A new table property, `file_creation_time`, is introduced to implement this feature. This property is set to the time at which the SST file was created (and that time is given by the underlying Env/OS).
This feature can be enabled on its own, or in conjunction with `ttl`. It is possible to set a different time threshold for the bottom level when used in conjunction with ttl. Since `ttl` works only on 0 to last but one levels, you could set `ttl` to, say, 1 day, and `periodic_compaction_time` to, say, 7 days. Since `ttl < periodic_compaction_time` all files in last but one levels keep getting picked up based on ttl, and almost never based on periodic_compaction_time. The files in the bottom level get picked up for compaction based on `periodic_compaction_time`.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5166
Differential Revision: D14884441
Pulled By: sagar0
fbshipit-source-id: 408426cbacb409c06386a98632dcf90bfa1bda47
2019-04-11 04:24:25 +02:00
|
|
|
uint64_t periodic_compaction_seconds;
|
2014-10-02 01:19:16 +02:00
|
|
|
std::vector<int> max_bytes_for_level_multiplier_additional;
|
2017-10-20 00:19:20 +02:00
|
|
|
CompactionOptionsFIFO compaction_options_fifo;
|
2017-12-11 22:12:12 +01:00
|
|
|
CompactionOptionsUniversal compaction_options_universal;
|
2014-10-02 01:19:16 +02:00
|
|
|
|
2020-08-19 03:31:31 +02:00
|
|
|
// Blob file related options
|
|
|
|
|
bool enable_blob_files;
|
|
|
|
|
uint64_t min_blob_size;
|
|
|
|
|
uint64_t blob_file_size;
|
|
|
|
|
CompressionType blob_compression_type;
|
2020-11-13 03:57:20 +01:00
|
|
|
bool enable_blob_garbage_collection;
|
|
|
|
|
double blob_garbage_collection_age_cutoff;
|
2020-08-19 03:31:31 +02:00
|
|
|
|
2014-10-24 00:34:21 +02:00
|
|
|
// Misc options
|
|
|
|
|
uint64_t max_sequential_skip_in_iterations;
|
2020-10-01 19:08:52 +02:00
|
|
|
bool check_flush_compaction_key_order;
|
2015-04-18 00:26:50 +02:00
|
|
|
bool paranoid_file_checks;
|
2016-04-14 22:56:29 +02:00
|
|
|
bool report_bg_io_stats;
|
2016-05-17 22:11:56 +02:00
|
|
|
CompressionType compression;
|
2020-03-31 21:08:41 +02:00
|
|
|
CompressionType bottommost_compression;
|
|
|
|
|
CompressionOptions compression_opts;
|
|
|
|
|
CompressionOptions bottommost_compression_opts;
|
2021-05-03 22:30:00 +02:00
|
|
|
// TODO this experimental option isn't made configurable
|
|
|
|
|
// through strings yet.
|
|
|
|
|
Temperature bottommost_temperature;
|
2020-03-31 21:08:41 +02:00
|
|
|
|
2019-03-18 20:07:35 +01:00
|
|
|
uint64_t sample_for_compression;
|
2014-10-24 00:34:21 +02:00
|
|
|
|
2014-10-02 01:19:16 +02:00
|
|
|
// Derived options
|
|
|
|
|
// Per-level target file size.
|
|
|
|
|
std::vector<uint64_t> max_file_size;
|
2014-09-17 21:49:13 +02:00
|
|
|
};
|
|
|
|
|
|
2016-11-02 05:05:32 +01:00
|
|
|
uint64_t MultiplyCheckOverflow(uint64_t op1, double op2);
|
options.level_compaction_dynamic_level_bytes to allow RocksDB to pick size bases of levels dynamically.
Summary:
When having fixed max_bytes_for_level_base, the ratio of size of largest level and the second one can range from 0 to the multiplier. This makes LSM tree frequently irregular and unpredictable. It can also cause poor space amplification in some cases.
In this improvement (proposed by Igor Kabiljo), we introduce a parameter option.level_compaction_use_dynamic_max_bytes. When turning it on, RocksDB is free to pick a level base in the range of (options.max_bytes_for_level_base/options.max_bytes_for_level_multiplier, options.max_bytes_for_level_base] so that real level ratios are close to options.max_bytes_for_level_multiplier.
Test Plan: New unit tests and pass tests suites including valgrind.
Reviewers: MarkCallaghan, rven, yhchiang, igor, ikabiljo
Reviewed By: ikabiljo
Subscribers: yoshinorim, ikabiljo, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D31437
2015-02-05 20:44:17 +01:00
|
|
|
|
2018-05-04 01:35:46 +02:00
|
|
|
// Get the max file size in a given level.
|
|
|
|
|
uint64_t MaxFileSizeForLevel(const MutableCFOptions& cf_options,
|
|
|
|
|
int level, CompactionStyle compaction_style, int base_level = 1,
|
|
|
|
|
bool level_compaction_dynamic_level_bytes = false);
|
2020-06-10 01:49:07 +02:00
|
|
|
|
|
|
|
|
// Get the max size of an L0 file for which we will pin its meta-blocks when
|
|
|
|
|
// `pin_l0_filter_and_index_blocks_in_cache` is set.
|
|
|
|
|
size_t MaxFileSizeForL0MetaPin(const MutableCFOptions& cf_options);
|
|
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
} // namespace ROCKSDB_NAMESPACE
|
