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-11-01 00:31:25 +01:00
|
|
|
//
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
|
2020-07-22 20:03:29 +02:00
|
|
|
#include "db/compaction/compaction_job.h"
|
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
#include <algorithm>
|
2019-09-20 21:00:55 +02:00
|
|
|
#include <cinttypes>
|
2015-09-10 22:50:00 +02:00
|
|
|
#include <functional>
|
2014-11-01 00:31:25 +01:00
|
|
|
#include <list>
|
Shared dictionary compression using reference block
Summary:
This adds a new metablock containing a shared dictionary that is used
to compress all data blocks in the SST file. The size of the shared dictionary
is configurable in CompressionOptions and defaults to 0. It's currently only
used for zlib/lz4/lz4hc, but the block will be stored in the SST regardless of
the compression type if the user chooses a nonzero dictionary size.
During compaction, computes the dictionary by randomly sampling the first
output file in each subcompaction. It pre-computes the intervals to sample
by assuming the output file will have the maximum allowable length. In case
the file is smaller, some of the pre-computed sampling intervals can be beyond
end-of-file, in which case we skip over those samples and the dictionary will
be a bit smaller. After the dictionary is generated using the first file in a
subcompaction, it is loaded into the compression library before writing each
block in each subsequent file of that subcompaction.
On the read path, gets the dictionary from the metablock, if it exists. Then,
loads that dictionary into the compression library before reading each block.
Test Plan: new unit test
Reviewers: yhchiang, IslamAbdelRahman, cyan, sdong
Reviewed By: sdong
Subscribers: andrewkr, yoshinorim, kradhakrishnan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D52287
2016-04-28 02:36:03 +02:00
|
|
|
#include <memory>
|
|
|
|
#include <random>
|
2015-09-10 22:50:00 +02:00
|
|
|
#include <set>
|
|
|
|
#include <thread>
|
|
|
|
#include <utility>
|
Shared dictionary compression using reference block
Summary:
This adds a new metablock containing a shared dictionary that is used
to compress all data blocks in the SST file. The size of the shared dictionary
is configurable in CompressionOptions and defaults to 0. It's currently only
used for zlib/lz4/lz4hc, but the block will be stored in the SST regardless of
the compression type if the user chooses a nonzero dictionary size.
During compaction, computes the dictionary by randomly sampling the first
output file in each subcompaction. It pre-computes the intervals to sample
by assuming the output file will have the maximum allowable length. In case
the file is smaller, some of the pre-computed sampling intervals can be beyond
end-of-file, in which case we skip over those samples and the dictionary will
be a bit smaller. After the dictionary is generated using the first file in a
subcompaction, it is loaded into the compression library before writing each
block in each subsequent file of that subcompaction.
On the read path, gets the dictionary from the metablock, if it exists. Then,
loads that dictionary into the compression library before reading each block.
Test Plan: new unit test
Reviewers: yhchiang, IslamAbdelRahman, cyan, sdong
Reviewed By: sdong
Subscribers: andrewkr, yoshinorim, kradhakrishnan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D52287
2016-04-28 02:36:03 +02:00
|
|
|
#include <vector>
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
#include "db/blob/blob_file_addition.h"
|
|
|
|
#include "db/blob/blob_file_builder.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "db/builder.h"
|
2021-06-10 00:40:16 +02:00
|
|
|
#include "db/compaction/clipping_iterator.h"
|
2019-05-31 20:52:59 +02:00
|
|
|
#include "db/db_impl/db_impl.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "db/db_iter.h"
|
|
|
|
#include "db/dbformat.h"
|
2018-06-28 21:23:57 +02:00
|
|
|
#include "db/error_handler.h"
|
2015-05-28 22:37:47 +02:00
|
|
|
#include "db/event_helpers.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "db/log_reader.h"
|
|
|
|
#include "db/log_writer.h"
|
|
|
|
#include "db/memtable.h"
|
|
|
|
#include "db/memtable_list.h"
|
|
|
|
#include "db/merge_context.h"
|
2015-09-10 23:35:25 +02:00
|
|
|
#include "db/merge_helper.h"
|
2020-10-01 19:08:52 +02:00
|
|
|
#include "db/output_validator.h"
|
2018-12-18 02:26:56 +01:00
|
|
|
#include "db/range_del_aggregator.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "db/version_set.h"
|
2019-05-30 05:44:08 +02:00
|
|
|
#include "file/filename.h"
|
2019-09-16 19:31:27 +02:00
|
|
|
#include "file/read_write_util.h"
|
2019-05-30 05:44:08 +02:00
|
|
|
#include "file/sst_file_manager_impl.h"
|
2019-09-16 19:31:27 +02:00
|
|
|
#include "file/writable_file_writer.h"
|
2019-06-01 02:19:43 +02:00
|
|
|
#include "logging/log_buffer.h"
|
|
|
|
#include "logging/logging.h"
|
2017-04-06 04:02:00 +02:00
|
|
|
#include "monitoring/iostats_context_imp.h"
|
|
|
|
#include "monitoring/perf_context_imp.h"
|
|
|
|
#include "monitoring/thread_status_util.h"
|
2021-05-12 21:34:22 +02:00
|
|
|
#include "options/configurable_helper.h"
|
2021-02-11 07:18:33 +01:00
|
|
|
#include "options/options_helper.h"
|
2015-09-10 23:35:25 +02:00
|
|
|
#include "port/port.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "rocksdb/db.h"
|
|
|
|
#include "rocksdb/env.h"
|
2020-07-24 22:43:14 +02:00
|
|
|
#include "rocksdb/sst_partitioner.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "rocksdb/statistics.h"
|
|
|
|
#include "rocksdb/status.h"
|
|
|
|
#include "rocksdb/table.h"
|
2021-05-12 21:34:22 +02:00
|
|
|
#include "rocksdb/utilities/options_type.h"
|
2019-05-30 23:47:29 +02:00
|
|
|
#include "table/block_based/block.h"
|
|
|
|
#include "table/block_based/block_based_table_factory.h"
|
2017-02-03 01:38:40 +01:00
|
|
|
#include "table/merging_iterator.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "table/table_builder.h"
|
2019-05-31 02:39:43 +02:00
|
|
|
#include "test_util/sync_point.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "util/coding.h"
|
2020-07-22 20:03:29 +02:00
|
|
|
#include "util/hash.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "util/mutexlock.h"
|
2017-04-06 22:59:31 +02:00
|
|
|
#include "util/random.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
#include "util/stop_watch.h"
|
Include bunch of more events into EventLogger
Summary:
Added these events:
* Recovery start, finish and also when recovery creates a file
* Trivial move
* Compaction start, finish and when compaction creates a file
* Flush start, finish
Also includes small fix to EventLogger
Also added option ROCKSDB_PRINT_EVENTS_TO_STDOUT which is useful when we debug things. I've spent far too much time chasing LOG files.
Still didn't get sst table properties in JSON. They are written very deeply into the stack. I'll address in separate diff.
TODO:
* Write specification. Let's first use this for a while and figure out what's good data to put here, too. After that we'll write spec
* Write tools that parse and analyze LOGs. This can be in python or go. Good intern task.
Test Plan: Ran db_bench with ROCKSDB_PRINT_EVENTS_TO_STDOUT. Here's the output: https://phabricator.fb.com/P19811976
Reviewers: sdong, yhchiang, rven, MarkCallaghan, kradhakrishnan, anthony
Reviewed By: anthony
Subscribers: dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D37521
2015-04-28 00:20:02 +02:00
|
|
|
#include "util/string_util.h"
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
namespace ROCKSDB_NAMESPACE {
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2018-04-11 19:47:54 +02:00
|
|
|
const char* GetCompactionReasonString(CompactionReason compaction_reason) {
|
|
|
|
switch (compaction_reason) {
|
|
|
|
case CompactionReason::kUnknown:
|
|
|
|
return "Unknown";
|
|
|
|
case CompactionReason::kLevelL0FilesNum:
|
|
|
|
return "LevelL0FilesNum";
|
|
|
|
case CompactionReason::kLevelMaxLevelSize:
|
|
|
|
return "LevelMaxLevelSize";
|
|
|
|
case CompactionReason::kUniversalSizeAmplification:
|
|
|
|
return "UniversalSizeAmplification";
|
|
|
|
case CompactionReason::kUniversalSizeRatio:
|
|
|
|
return "UniversalSizeRatio";
|
|
|
|
case CompactionReason::kUniversalSortedRunNum:
|
|
|
|
return "UniversalSortedRunNum";
|
|
|
|
case CompactionReason::kFIFOMaxSize:
|
|
|
|
return "FIFOMaxSize";
|
|
|
|
case CompactionReason::kFIFOReduceNumFiles:
|
|
|
|
return "FIFOReduceNumFiles";
|
|
|
|
case CompactionReason::kFIFOTtl:
|
|
|
|
return "FIFOTtl";
|
|
|
|
case CompactionReason::kManualCompaction:
|
|
|
|
return "ManualCompaction";
|
|
|
|
case CompactionReason::kFilesMarkedForCompaction:
|
|
|
|
return "FilesMarkedForCompaction";
|
|
|
|
case CompactionReason::kBottommostFiles:
|
|
|
|
return "BottommostFiles";
|
|
|
|
case CompactionReason::kTtl:
|
|
|
|
return "Ttl";
|
|
|
|
case CompactionReason::kFlush:
|
|
|
|
return "Flush";
|
|
|
|
case CompactionReason::kExternalSstIngestion:
|
|
|
|
return "ExternalSstIngestion";
|
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
|
|
|
case CompactionReason::kPeriodicCompaction:
|
|
|
|
return "PeriodicCompaction";
|
2018-04-11 19:47:54 +02:00
|
|
|
case CompactionReason::kNumOfReasons:
|
|
|
|
// fall through
|
|
|
|
default:
|
|
|
|
assert(false);
|
|
|
|
return "Invalid";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
// Maintains state for each sub-compaction
|
2015-09-10 22:50:00 +02:00
|
|
|
struct CompactionJob::SubcompactionState {
|
2016-03-25 03:36:39 +01:00
|
|
|
const Compaction* compaction;
|
2015-09-10 23:35:25 +02:00
|
|
|
std::unique_ptr<CompactionIterator> c_iter;
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
// The boundaries of the key-range this compaction is interested in. No two
|
|
|
|
// subcompactions may have overlapping key-ranges.
|
|
|
|
// 'start' is inclusive, 'end' is exclusive, and nullptr means unbounded
|
|
|
|
Slice *start, *end;
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
// The return status of this subcompaction
|
2015-08-18 20:06:23 +02:00
|
|
|
Status status;
|
|
|
|
|
2020-07-15 20:02:44 +02:00
|
|
|
// The return IO Status of this subcompaction
|
|
|
|
IOStatus io_status;
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
// Files produced by this subcompaction
|
2014-11-01 00:31:25 +01:00
|
|
|
struct Output {
|
2020-10-01 19:08:52 +02:00
|
|
|
Output(FileMetaData&& _meta, const InternalKeyComparator& _icmp,
|
2021-05-20 06:40:43 +02:00
|
|
|
bool _enable_order_check, bool _enable_hash, bool _finished = false,
|
|
|
|
uint64_t precalculated_hash = 0)
|
2020-10-01 19:08:52 +02:00
|
|
|
: meta(std::move(_meta)),
|
2021-05-20 06:40:43 +02:00
|
|
|
validator(_icmp, _enable_order_check, _enable_hash,
|
|
|
|
precalculated_hash),
|
|
|
|
finished(_finished) {}
|
2015-09-10 23:35:25 +02:00
|
|
|
FileMetaData meta;
|
2020-10-01 19:08:52 +02:00
|
|
|
OutputValidator validator;
|
2015-09-10 23:35:25 +02:00
|
|
|
bool finished;
|
2015-09-15 18:03:08 +02:00
|
|
|
std::shared_ptr<const TableProperties> table_properties;
|
2014-11-01 00:31:25 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// State kept for output being generated
|
2015-08-18 20:06:23 +02:00
|
|
|
std::vector<Output> outputs;
|
2020-10-26 21:50:03 +01:00
|
|
|
std::vector<BlobFileAddition> blob_file_additions;
|
Move rate_limiter, write buffering, most perf context instrumentation and most random kill out of Env
Summary: We want to keep Env a think layer for better portability. Less platform dependent codes should be moved out of Env. In this patch, I create a wrapper of file readers and writers, and put rate limiting, write buffering, as well as most perf context instrumentation and random kill out of Env. It will make it easier to maintain multiple Env in the future.
Test Plan: Run all existing unit tests.
Reviewers: anthony, kradhakrishnan, IslamAbdelRahman, yhchiang, igor
Reviewed By: igor
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D42321
2015-07-18 01:16:11 +02:00
|
|
|
std::unique_ptr<WritableFileWriter> outfile;
|
2014-11-01 00:31:25 +01:00
|
|
|
std::unique_ptr<TableBuilder> builder;
|
2020-09-08 18:22:46 +02:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
Output* current_output() {
|
2015-08-18 21:27:12 +02:00
|
|
|
if (outputs.empty()) {
|
2020-07-22 20:03:29 +02:00
|
|
|
// This subcompaction's output could be empty if compaction was aborted
|
2015-08-18 21:27:12 +02:00
|
|
|
// before this subcompaction had a chance to generate any output files.
|
|
|
|
// When subcompactions are executed sequentially this is more likely and
|
2021-03-26 05:17:17 +01:00
|
|
|
// will be particularly likely for the later subcompactions to be empty.
|
2015-08-18 21:27:12 +02:00
|
|
|
// Once they are run in parallel however it should be much rarer.
|
|
|
|
return nullptr;
|
|
|
|
} else {
|
|
|
|
return &outputs.back();
|
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-09-08 18:22:46 +02:00
|
|
|
uint64_t current_output_file_size = 0;
|
2016-06-17 01:02:52 +02:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
// State during the subcompaction
|
2020-09-08 18:22:46 +02:00
|
|
|
uint64_t total_bytes = 0;
|
|
|
|
uint64_t num_output_records = 0;
|
2015-08-18 20:06:23 +02:00
|
|
|
CompactionJobStats compaction_job_stats;
|
2020-09-08 18:22:46 +02:00
|
|
|
uint64_t approx_size = 0;
|
2016-04-12 05:15:52 +02:00
|
|
|
// An index that used to speed up ShouldStopBefore().
|
2016-03-25 03:36:39 +01:00
|
|
|
size_t grandparent_index = 0;
|
|
|
|
// The number of bytes overlapping between the current output and
|
2016-04-12 05:15:52 +02:00
|
|
|
// grandparent files used in ShouldStopBefore().
|
2016-03-25 03:36:39 +01:00
|
|
|
uint64_t overlapped_bytes = 0;
|
2016-04-12 05:15:52 +02:00
|
|
|
// A flag determine whether the key has been seen in ShouldStopBefore()
|
2016-03-25 03:36:39 +01:00
|
|
|
bool seen_key = false;
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2020-09-08 18:22:46 +02:00
|
|
|
SubcompactionState(Compaction* c, Slice* _start, Slice* _end, uint64_t size)
|
|
|
|
: compaction(c), start(_start), end(_end), approx_size(size) {
|
2015-08-20 23:14:02 +02:00
|
|
|
assert(compaction != nullptr);
|
|
|
|
}
|
2015-08-20 23:08:24 +02:00
|
|
|
|
2020-07-22 20:03:29 +02:00
|
|
|
// Adds the key and value to the builder
|
|
|
|
// If paranoid is true, adds the key-value to the paranoid hash
|
2020-10-01 19:08:52 +02:00
|
|
|
Status AddToBuilder(const Slice& key, const Slice& value) {
|
2020-07-22 20:03:29 +02:00
|
|
|
auto curr = current_output();
|
|
|
|
assert(builder != nullptr);
|
|
|
|
assert(curr != nullptr);
|
2020-10-01 19:08:52 +02:00
|
|
|
Status s = curr->validator.Add(key, value);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
2020-07-22 20:03:29 +02:00
|
|
|
}
|
|
|
|
builder->Add(key, value);
|
2020-10-01 19:08:52 +02:00
|
|
|
return Status::OK();
|
2020-07-22 20:03:29 +02:00
|
|
|
}
|
|
|
|
|
2016-03-25 03:36:39 +01:00
|
|
|
// Returns true iff we should stop building the current output
|
|
|
|
// before processing "internal_key".
|
2016-06-17 01:02:52 +02:00
|
|
|
bool ShouldStopBefore(const Slice& internal_key, uint64_t curr_file_size) {
|
2016-03-25 03:36:39 +01:00
|
|
|
const InternalKeyComparator* icmp =
|
|
|
|
&compaction->column_family_data()->internal_comparator();
|
|
|
|
const std::vector<FileMetaData*>& grandparents = compaction->grandparents();
|
|
|
|
|
|
|
|
// Scan to find earliest grandparent file that contains key.
|
|
|
|
while (grandparent_index < grandparents.size() &&
|
|
|
|
icmp->Compare(internal_key,
|
|
|
|
grandparents[grandparent_index]->largest.Encode()) >
|
|
|
|
0) {
|
|
|
|
if (seen_key) {
|
|
|
|
overlapped_bytes += grandparents[grandparent_index]->fd.GetFileSize();
|
|
|
|
}
|
|
|
|
assert(grandparent_index + 1 >= grandparents.size() ||
|
|
|
|
icmp->Compare(
|
|
|
|
grandparents[grandparent_index]->largest.Encode(),
|
2016-04-12 05:15:52 +02:00
|
|
|
grandparents[grandparent_index + 1]->smallest.Encode()) <= 0);
|
2016-03-25 03:36:39 +01:00
|
|
|
grandparent_index++;
|
|
|
|
}
|
|
|
|
seen_key = true;
|
|
|
|
|
2016-06-17 01:02:52 +02:00
|
|
|
if (overlapped_bytes + curr_file_size >
|
|
|
|
compaction->max_compaction_bytes()) {
|
2016-03-25 03:36:39 +01:00
|
|
|
// Too much overlap for current output; start new output
|
|
|
|
overlapped_bytes = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
// Maintains state for the entire compaction
|
|
|
|
struct CompactionJob::CompactionState {
|
|
|
|
Compaction* const compaction;
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
// REQUIRED: subcompaction states are stored in order of increasing
|
|
|
|
// key-range
|
2015-09-10 22:50:00 +02:00
|
|
|
std::vector<CompactionJob::SubcompactionState> sub_compact_states;
|
2015-08-18 20:06:23 +02:00
|
|
|
Status status;
|
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
size_t num_output_files = 0;
|
|
|
|
uint64_t total_bytes = 0;
|
|
|
|
size_t num_blob_output_files = 0;
|
|
|
|
uint64_t total_blob_bytes = 0;
|
|
|
|
uint64_t num_output_records = 0;
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
explicit CompactionState(Compaction* c) : compaction(c) {}
|
2015-08-18 20:06:23 +02:00
|
|
|
|
|
|
|
Slice SmallestUserKey() {
|
2015-09-10 23:35:25 +02:00
|
|
|
for (const auto& sub_compact_state : sub_compact_states) {
|
|
|
|
if (!sub_compact_state.outputs.empty() &&
|
|
|
|
sub_compact_state.outputs[0].finished) {
|
|
|
|
return sub_compact_state.outputs[0].meta.smallest.user_key();
|
2015-08-18 21:27:12 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
// If there is no finished output, return an empty slice.
|
2015-08-18 21:27:12 +02:00
|
|
|
return Slice(nullptr, 0);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Slice LargestUserKey() {
|
2015-09-10 23:35:25 +02:00
|
|
|
for (auto it = sub_compact_states.rbegin(); it < sub_compact_states.rend();
|
|
|
|
++it) {
|
|
|
|
if (!it->outputs.empty() && it->current_output()->finished) {
|
|
|
|
assert(it->current_output() != nullptr);
|
|
|
|
return it->current_output()->meta.largest.user_key();
|
2015-08-18 21:27:12 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
// If there is no finished output, return an empty slice.
|
2015-08-18 21:27:12 +02:00
|
|
|
return Slice(nullptr, 0);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
};
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
void CompactionJob::AggregateStatistics() {
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(compact_);
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
for (SubcompactionState& sc : compact_->sub_compact_states) {
|
2020-10-26 21:50:03 +01:00
|
|
|
auto& outputs = sc.outputs;
|
|
|
|
|
|
|
|
if (!outputs.empty() && !outputs.back().meta.fd.file_size) {
|
|
|
|
// An error occurred, so ignore the last output.
|
|
|
|
outputs.pop_back();
|
|
|
|
}
|
|
|
|
|
|
|
|
compact_->num_output_files += outputs.size();
|
2015-08-18 20:06:23 +02:00
|
|
|
compact_->total_bytes += sc.total_bytes;
|
2020-10-26 21:50:03 +01:00
|
|
|
|
|
|
|
const auto& blobs = sc.blob_file_additions;
|
|
|
|
|
|
|
|
compact_->num_blob_output_files += blobs.size();
|
|
|
|
|
|
|
|
for (const auto& blob : blobs) {
|
|
|
|
compact_->total_blob_bytes += blob.GetTotalBlobBytes();
|
|
|
|
}
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
compact_->num_output_records += sc.num_output_records;
|
2020-10-26 21:50:03 +01:00
|
|
|
|
2020-10-01 21:51:33 +02:00
|
|
|
compaction_job_stats_->Add(sc.compaction_job_stats);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
CompactionJob::CompactionJob(
|
2016-09-24 01:34:04 +02:00
|
|
|
int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
|
2021-05-20 06:40:43 +02:00
|
|
|
const MutableDBOptions& mutable_db_options, const FileOptions& file_options,
|
|
|
|
VersionSet* versions, const std::atomic<bool>* shutting_down,
|
2017-11-17 02:46:43 +01:00
|
|
|
const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
|
2020-10-26 21:50:03 +01:00
|
|
|
FSDirectory* db_directory, FSDirectory* output_directory,
|
|
|
|
FSDirectory* blob_output_directory, Statistics* stats,
|
2018-06-28 21:23:57 +02:00
|
|
|
InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
|
2015-05-06 04:01:12 +02:00
|
|
|
std::vector<SequenceNumber> existing_snapshots,
|
2015-12-08 21:25:48 +01:00
|
|
|
SequenceNumber earliest_write_conflict_snapshot,
|
2017-10-06 19:26:38 +02:00
|
|
|
const SnapshotChecker* snapshot_checker, std::shared_ptr<Cache> table_cache,
|
|
|
|
EventLogger* event_logger, bool paranoid_file_checks, bool measure_io_stats,
|
2019-03-20 01:24:09 +01:00
|
|
|
const std::string& dbname, CompactionJobStats* compaction_job_stats,
|
2020-08-13 02:28:10 +02:00
|
|
|
Env::Priority thread_pri, const std::shared_ptr<IOTracer>& io_tracer,
|
2021-06-07 20:40:31 +02:00
|
|
|
const std::atomic<int>* manual_compaction_paused,
|
|
|
|
const std::atomic<bool>* manual_compaction_canceled,
|
|
|
|
const std::string& db_id, const std::string& db_session_id,
|
|
|
|
std::string full_history_ts_low, BlobFileCompletionCallback* blob_callback)
|
2021-04-22 22:01:00 +02:00
|
|
|
: compact_(new CompactionState(compaction)),
|
2018-04-11 19:47:54 +02:00
|
|
|
compaction_stats_(compaction->compaction_reason(), 1),
|
2021-04-22 22:01:00 +02:00
|
|
|
db_options_(db_options),
|
2021-05-20 06:40:43 +02:00
|
|
|
mutable_db_options_copy_(mutable_db_options),
|
2021-04-22 22:01:00 +02:00
|
|
|
log_buffer_(log_buffer),
|
|
|
|
output_directory_(output_directory),
|
|
|
|
stats_(stats),
|
|
|
|
bottommost_level_(false),
|
|
|
|
write_hint_(Env::WLTH_NOT_SET),
|
|
|
|
job_id_(job_id),
|
|
|
|
compaction_job_stats_(compaction_job_stats),
|
2015-06-02 23:12:23 +02:00
|
|
|
dbname_(dbname),
|
2020-06-17 19:55:42 +02:00
|
|
|
db_id_(db_id),
|
|
|
|
db_session_id_(db_session_id),
|
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
|
|
|
file_options_(file_options),
|
2014-11-01 00:31:25 +01:00
|
|
|
env_(db_options.env),
|
2020-09-08 19:49:01 +02:00
|
|
|
io_tracer_(io_tracer),
|
2020-08-13 02:28:10 +02:00
|
|
|
fs_(db_options.fs, io_tracer),
|
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
|
|
|
file_options_for_read_(
|
|
|
|
fs_->OptimizeForCompactionTableRead(file_options, db_options_)),
|
2014-11-01 00:31:25 +01:00
|
|
|
versions_(versions),
|
|
|
|
shutting_down_(shutting_down),
|
2019-09-17 06:00:13 +02:00
|
|
|
manual_compaction_paused_(manual_compaction_paused),
|
2021-06-07 20:40:31 +02:00
|
|
|
manual_compaction_canceled_(manual_compaction_canceled),
|
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
|
|
|
preserve_deletes_seqnum_(preserve_deletes_seqnum),
|
2014-11-01 00:31:25 +01:00
|
|
|
db_directory_(db_directory),
|
2020-10-26 21:50:03 +01:00
|
|
|
blob_output_directory_(blob_output_directory),
|
2016-02-18 00:20:23 +01:00
|
|
|
db_mutex_(db_mutex),
|
2018-06-28 21:23:57 +02:00
|
|
|
db_error_handler_(db_error_handler),
|
2015-05-06 04:01:12 +02:00
|
|
|
existing_snapshots_(std::move(existing_snapshots)),
|
2015-12-08 21:25:48 +01:00
|
|
|
earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
|
2017-10-06 19:26:38 +02:00
|
|
|
snapshot_checker_(snapshot_checker),
|
2014-11-01 00:31:25 +01:00
|
|
|
table_cache_(std::move(table_cache)),
|
2015-05-06 04:01:12 +02:00
|
|
|
event_logger_(event_logger),
|
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_(paranoid_file_checks),
|
2017-11-10 18:25:26 +01:00
|
|
|
measure_io_stats_(measure_io_stats),
|
2020-11-12 20:40:52 +01:00
|
|
|
thread_pri_(thread_pri),
|
2021-03-18 04:43:22 +01:00
|
|
|
full_history_ts_low_(std::move(full_history_ts_low)),
|
|
|
|
blob_callback_(blob_callback) {
|
2020-10-01 21:51:33 +02:00
|
|
|
assert(compaction_job_stats_ != nullptr);
|
2015-07-15 08:12:34 +02:00
|
|
|
assert(log_buffer_ != nullptr);
|
2016-01-26 01:26:53 +01:00
|
|
|
const auto* cfd = compact_->compaction->column_family_data();
|
|
|
|
ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
|
2016-09-17 00:09:14 +02:00
|
|
|
db_options_.enable_thread_tracking);
|
2015-03-13 18:45:40 +01:00
|
|
|
ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);
|
2015-05-07 07:50:35 +02:00
|
|
|
ReportStartedCompaction(compaction);
|
2015-03-13 18:45:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
CompactionJob::~CompactionJob() {
|
|
|
|
assert(compact_ == nullptr);
|
|
|
|
ThreadStatusUtil::ResetThreadStatus();
|
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2018-04-13 02:55:14 +02:00
|
|
|
void CompactionJob::ReportStartedCompaction(Compaction* compaction) {
|
2016-01-26 01:26:53 +01:00
|
|
|
const auto* cfd = compact_->compaction->column_family_data();
|
|
|
|
ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
|
2016-09-17 00:09:14 +02:00
|
|
|
db_options_.enable_thread_tracking);
|
2015-05-07 07:50:35 +02:00
|
|
|
|
2018-04-13 02:55:14 +02:00
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(ThreadStatus::COMPACTION_JOB_ID,
|
|
|
|
job_id_);
|
2015-05-07 07:50:35 +02:00
|
|
|
|
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_INPUT_OUTPUT_LEVEL,
|
|
|
|
(static_cast<uint64_t>(compact_->compaction->start_level()) << 32) +
|
|
|
|
compact_->compaction->output_level());
|
|
|
|
|
2015-06-03 02:07:16 +02:00
|
|
|
// In the current design, a CompactionJob is always created
|
|
|
|
// for non-trivial compaction.
|
|
|
|
assert(compaction->IsTrivialMove() == false ||
|
2015-07-09 00:21:10 +02:00
|
|
|
compaction->is_manual_compaction() == true);
|
2015-06-03 02:07:16 +02:00
|
|
|
|
2015-05-07 07:50:35 +02:00
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_PROP_FLAGS,
|
2015-07-13 21:11:05 +02:00
|
|
|
compaction->is_manual_compaction() +
|
2015-07-09 00:21:10 +02:00
|
|
|
(compaction->deletion_compaction() << 1));
|
2015-05-07 07:50:35 +02:00
|
|
|
|
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_TOTAL_INPUT_BYTES,
|
|
|
|
compaction->CalculateTotalInputSize());
|
|
|
|
|
|
|
|
IOSTATS_RESET(bytes_written);
|
|
|
|
IOSTATS_RESET(bytes_read);
|
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_BYTES_WRITTEN, 0);
|
|
|
|
ThreadStatusUtil::SetThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_BYTES_READ, 0);
|
|
|
|
|
|
|
|
// Set the thread operation after operation properties
|
|
|
|
// to ensure GetThreadList() can always show them all together.
|
2018-04-13 02:55:14 +02:00
|
|
|
ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);
|
2015-06-03 02:07:16 +02:00
|
|
|
|
2020-10-01 21:51:33 +02:00
|
|
|
compaction_job_stats_->is_manual_compaction =
|
|
|
|
compaction->is_manual_compaction();
|
|
|
|
compaction_job_stats_->is_full_compaction = compaction->is_full_compaction();
|
2015-05-07 07:50:35 +02:00
|
|
|
}
|
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
void CompactionJob::Prepare() {
|
2015-03-13 18:45:40 +01:00
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_PREPARE);
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2021-03-26 05:17:17 +01:00
|
|
|
// Generate file_levels_ for compaction before making Iterator
|
2015-08-19 17:52:22 +02:00
|
|
|
auto* c = compact_->compaction;
|
|
|
|
assert(c->column_family_data() != nullptr);
|
2018-04-13 02:55:14 +02:00
|
|
|
assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
|
|
|
|
compact_->compaction->level()) > 0);
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2018-04-13 02:55:14 +02:00
|
|
|
write_hint_ =
|
|
|
|
c->column_family_data()->CalculateSSTWriteHint(c->output_level());
|
2015-08-19 17:52:22 +02:00
|
|
|
bottommost_level_ = c->bottommost_level();
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
if (c->ShouldFormSubcompactions()) {
|
2019-02-28 19:14:19 +01:00
|
|
|
{
|
2021-03-15 12:32:24 +01:00
|
|
|
StopWatch sw(db_options_.clock, stats_, SUBCOMPACTION_SETUP_TIME);
|
2019-02-28 19:14:19 +01:00
|
|
|
GenSubcompactionBoundaries();
|
|
|
|
}
|
2015-09-10 22:50:00 +02:00
|
|
|
assert(sizes_.size() == boundaries_.size() + 1);
|
|
|
|
|
|
|
|
for (size_t i = 0; i <= boundaries_.size(); i++) {
|
|
|
|
Slice* start = i == 0 ? nullptr : &boundaries_[i - 1];
|
|
|
|
Slice* end = i == boundaries_.size() ? nullptr : &boundaries_[i];
|
|
|
|
compact_->sub_compact_states.emplace_back(c, start, end, sizes_[i]);
|
|
|
|
}
|
2019-02-28 19:14:19 +01:00
|
|
|
RecordInHistogram(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
|
|
|
|
compact_->sub_compact_states.size());
|
2015-09-10 22:50:00 +02:00
|
|
|
} else {
|
2020-09-08 18:22:46 +02:00
|
|
|
constexpr Slice* start = nullptr;
|
|
|
|
constexpr Slice* end = nullptr;
|
|
|
|
constexpr uint64_t size = 0;
|
|
|
|
|
|
|
|
compact_->sub_compact_states.emplace_back(c, start, end, size);
|
2015-09-10 22:50:00 +02:00
|
|
|
}
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
}
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
struct RangeWithSize {
|
|
|
|
Range range;
|
|
|
|
uint64_t size;
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
RangeWithSize(const Slice& a, const Slice& b, uint64_t s = 0)
|
|
|
|
: range(a, b), size(s) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
void CompactionJob::GenSubcompactionBoundaries() {
|
|
|
|
auto* c = compact_->compaction;
|
|
|
|
auto* cfd = c->column_family_data();
|
2015-12-22 07:34:57 +01:00
|
|
|
const Comparator* cfd_comparator = cfd->user_comparator();
|
|
|
|
std::vector<Slice> bounds;
|
2015-09-10 22:50:00 +02:00
|
|
|
int start_lvl = c->start_level();
|
|
|
|
int out_lvl = c->output_level();
|
|
|
|
|
|
|
|
// Add the starting and/or ending key of certain input files as a potential
|
2015-12-22 07:34:57 +01:00
|
|
|
// boundary
|
2015-09-10 22:50:00 +02:00
|
|
|
for (size_t lvl_idx = 0; lvl_idx < c->num_input_levels(); lvl_idx++) {
|
|
|
|
int lvl = c->level(lvl_idx);
|
|
|
|
if (lvl >= start_lvl && lvl <= out_lvl) {
|
|
|
|
const LevelFilesBrief* flevel = c->input_levels(lvl_idx);
|
|
|
|
size_t num_files = flevel->num_files;
|
|
|
|
|
|
|
|
if (num_files == 0) {
|
2016-03-02 20:21:26 +01:00
|
|
|
continue;
|
2015-09-10 22:50:00 +02:00
|
|
|
}
|
2015-08-18 23:56:31 +02:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
if (lvl == 0) {
|
|
|
|
// For level 0 add the starting and ending key of each file since the
|
|
|
|
// files may have greatly differing key ranges (not range-partitioned)
|
|
|
|
for (size_t i = 0; i < num_files; i++) {
|
2015-12-22 07:34:57 +01:00
|
|
|
bounds.emplace_back(flevel->files[i].smallest_key);
|
|
|
|
bounds.emplace_back(flevel->files[i].largest_key);
|
2015-09-10 22:50:00 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// For all other levels add the smallest/largest key in the level to
|
|
|
|
// encompass the range covered by that level
|
2015-12-22 07:34:57 +01:00
|
|
|
bounds.emplace_back(flevel->files[0].smallest_key);
|
|
|
|
bounds.emplace_back(flevel->files[num_files - 1].largest_key);
|
2015-09-10 22:50:00 +02:00
|
|
|
if (lvl == out_lvl) {
|
|
|
|
// For the last level include the starting keys of all files since
|
|
|
|
// the last level is the largest and probably has the widest key
|
|
|
|
// range. Since it's range partitioned, the ending key of one file
|
|
|
|
// and the starting key of the next are very close (or identical).
|
|
|
|
for (size_t i = 1; i < num_files; i++) {
|
2015-12-22 07:34:57 +01:00
|
|
|
bounds.emplace_back(flevel->files[i].smallest_key);
|
2015-08-18 23:56:31 +02:00
|
|
|
}
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-12-22 07:34:57 +01:00
|
|
|
std::sort(bounds.begin(), bounds.end(),
|
2018-04-13 02:55:14 +02:00
|
|
|
[cfd_comparator](const Slice& a, const Slice& b) -> bool {
|
|
|
|
return cfd_comparator->Compare(ExtractUserKey(a),
|
|
|
|
ExtractUserKey(b)) < 0;
|
|
|
|
});
|
2015-12-22 07:34:57 +01:00
|
|
|
// Remove duplicated entries from bounds
|
2018-04-13 02:55:14 +02:00
|
|
|
bounds.erase(
|
|
|
|
std::unique(bounds.begin(), bounds.end(),
|
|
|
|
[cfd_comparator](const Slice& a, const Slice& b) -> bool {
|
|
|
|
return cfd_comparator->Compare(ExtractUserKey(a),
|
|
|
|
ExtractUserKey(b)) == 0;
|
|
|
|
}),
|
|
|
|
bounds.end());
|
2015-12-22 07:34:57 +01:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
// Combine consecutive pairs of boundaries into ranges with an approximate
|
|
|
|
// size of data covered by keys in that range
|
|
|
|
uint64_t sum = 0;
|
|
|
|
std::vector<RangeWithSize> ranges;
|
2018-11-14 02:02:26 +01:00
|
|
|
// Get input version from CompactionState since it's already referenced
|
|
|
|
// earlier in SetInputVersioCompaction::SetInputVersion and will not change
|
|
|
|
// when db_mutex_ is released below
|
|
|
|
auto* v = compact_->compaction->input_version();
|
2015-09-10 22:50:00 +02:00
|
|
|
for (auto it = bounds.begin();;) {
|
|
|
|
const Slice a = *it;
|
2019-05-15 22:14:18 +02:00
|
|
|
++it;
|
2015-09-10 22:50:00 +02:00
|
|
|
|
|
|
|
if (it == bounds.end()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Slice b = *it;
|
2018-11-14 02:02:26 +01:00
|
|
|
|
|
|
|
// ApproximateSize could potentially create table reader iterator to seek
|
|
|
|
// to the index block and may incur I/O cost in the process. Unlock db
|
|
|
|
// mutex to reduce contention
|
|
|
|
db_mutex_->Unlock();
|
2019-07-31 17:46:48 +02:00
|
|
|
uint64_t size = versions_->ApproximateSize(SizeApproximationOptions(), v, a,
|
|
|
|
b, start_lvl, out_lvl + 1,
|
2019-06-20 23:28:22 +02:00
|
|
|
TableReaderCaller::kCompaction);
|
2018-11-14 02:02:26 +01:00
|
|
|
db_mutex_->Lock();
|
2015-09-10 22:50:00 +02:00
|
|
|
ranges.emplace_back(a, b, size);
|
|
|
|
sum += size;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Group the ranges into subcompactions
|
|
|
|
const double min_file_fill_percent = 4.0 / 5;
|
2018-05-04 01:35:46 +02:00
|
|
|
int base_level = v->storage_info()->base_level();
|
|
|
|
uint64_t max_output_files = static_cast<uint64_t>(std::ceil(
|
|
|
|
sum / min_file_fill_percent /
|
|
|
|
MaxFileSizeForLevel(*(c->mutable_cf_options()), out_lvl,
|
|
|
|
c->immutable_cf_options()->compaction_style, base_level,
|
|
|
|
c->immutable_cf_options()->level_compaction_dynamic_level_bytes)));
|
2015-09-10 22:50:00 +02:00
|
|
|
uint64_t subcompactions =
|
|
|
|
std::min({static_cast<uint64_t>(ranges.size()),
|
2018-04-27 20:48:21 +02:00
|
|
|
static_cast<uint64_t>(c->max_subcompactions()),
|
2015-09-10 22:50:00 +02:00
|
|
|
max_output_files});
|
|
|
|
|
|
|
|
if (subcompactions > 1) {
|
2016-11-29 01:31:41 +01:00
|
|
|
double mean = sum * 1.0 / subcompactions;
|
2015-09-10 22:50:00 +02:00
|
|
|
// Greedily add ranges to the subcompaction until the sum of the ranges'
|
|
|
|
// sizes becomes >= the expected mean size of a subcompaction
|
|
|
|
sum = 0;
|
2020-06-03 00:02:44 +02:00
|
|
|
for (size_t i = 0; i + 1 < ranges.size(); i++) {
|
2015-12-22 11:37:51 +01:00
|
|
|
sum += ranges[i].size;
|
2015-09-10 22:50:00 +02:00
|
|
|
if (subcompactions == 1) {
|
|
|
|
// If there's only one left to schedule then it goes to the end so no
|
|
|
|
// need to put an end boundary
|
2015-12-22 11:37:51 +01:00
|
|
|
continue;
|
2015-09-10 22:50:00 +02:00
|
|
|
}
|
|
|
|
if (sum >= mean) {
|
|
|
|
boundaries_.emplace_back(ExtractUserKey(ranges[i].range.limit));
|
|
|
|
sizes_.emplace_back(sum);
|
|
|
|
subcompactions--;
|
|
|
|
sum = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sizes_.emplace_back(sum + ranges.back().size);
|
|
|
|
} else {
|
|
|
|
// Only one range so its size is the total sum of sizes computed above
|
|
|
|
sizes_.emplace_back(sum);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Status CompactionJob::Run() {
|
2015-03-13 18:45:40 +01:00
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_RUN);
|
2015-03-13 19:59:00 +01:00
|
|
|
TEST_SYNC_POINT("CompactionJob::Run():Start");
|
2014-11-01 00:31:25 +01:00
|
|
|
log_buffer_->FlushBufferToLog();
|
2015-08-18 20:06:23 +02:00
|
|
|
LogCompaction();
|
Include bunch of more events into EventLogger
Summary:
Added these events:
* Recovery start, finish and also when recovery creates a file
* Trivial move
* Compaction start, finish and when compaction creates a file
* Flush start, finish
Also includes small fix to EventLogger
Also added option ROCKSDB_PRINT_EVENTS_TO_STDOUT which is useful when we debug things. I've spent far too much time chasing LOG files.
Still didn't get sst table properties in JSON. They are written very deeply into the stack. I'll address in separate diff.
TODO:
* Write specification. Let's first use this for a while and figure out what's good data to put here, too. After that we'll write spec
* Write tools that parse and analyze LOGs. This can be in python or go. Good intern task.
Test Plan: Ran db_bench with ROCKSDB_PRINT_EVENTS_TO_STDOUT. Here's the output: https://phabricator.fb.com/P19811976
Reviewers: sdong, yhchiang, rven, MarkCallaghan, kradhakrishnan, anthony
Reviewed By: anthony
Subscribers: dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D37521
2015-04-28 00:20:02 +02:00
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
const size_t num_threads = compact_->sub_compact_states.size();
|
|
|
|
assert(num_threads > 0);
|
2021-03-15 12:32:24 +01:00
|
|
|
const uint64_t start_micros = db_options_.clock->NowMicros();
|
2015-09-10 22:50:00 +02:00
|
|
|
|
|
|
|
// Launch a thread for each of subcompactions 1...num_threads-1
|
2017-02-06 23:43:55 +01:00
|
|
|
std::vector<port::Thread> thread_pool;
|
2015-09-10 22:50:00 +02:00
|
|
|
thread_pool.reserve(num_threads - 1);
|
|
|
|
for (size_t i = 1; i < compact_->sub_compact_states.size(); i++) {
|
|
|
|
thread_pool.emplace_back(&CompactionJob::ProcessKeyValueCompaction, this,
|
|
|
|
&compact_->sub_compact_states[i]);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
2015-09-10 22:50:00 +02:00
|
|
|
|
|
|
|
// Always schedule the first subcompaction (whether or not there are also
|
|
|
|
// others) in the current thread to be efficient with resources
|
|
|
|
ProcessKeyValueCompaction(&compact_->sub_compact_states[0]);
|
|
|
|
|
|
|
|
// Wait for all other threads (if there are any) to finish execution
|
|
|
|
for (auto& thread : thread_pool) {
|
|
|
|
thread.join();
|
|
|
|
}
|
|
|
|
|
2021-03-15 12:32:24 +01:00
|
|
|
compaction_stats_.micros = db_options_.clock->NowMicros() - start_micros;
|
2019-01-30 01:23:21 +01:00
|
|
|
compaction_stats_.cpu_micros = 0;
|
|
|
|
for (size_t i = 0; i < compact_->sub_compact_states.size(); i++) {
|
|
|
|
compaction_stats_.cpu_micros +=
|
|
|
|
compact_->sub_compact_states[i].compaction_job_stats.cpu_micros;
|
|
|
|
}
|
|
|
|
|
2019-02-28 19:14:19 +01:00
|
|
|
RecordTimeToHistogram(stats_, COMPACTION_TIME, compaction_stats_.micros);
|
|
|
|
RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
|
|
|
|
compaction_stats_.cpu_micros);
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
|
2018-08-14 02:31:58 +02:00
|
|
|
TEST_SYNC_POINT("CompactionJob::Run:BeforeVerify");
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
// Check if any thread encountered an error during execution
|
2015-08-18 20:06:23 +02:00
|
|
|
Status status;
|
2020-07-15 20:02:44 +02:00
|
|
|
IOStatus io_s;
|
2020-10-26 21:50:03 +01:00
|
|
|
bool wrote_new_blob_files = false;
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
for (const auto& state : compact_->sub_compact_states) {
|
|
|
|
if (!state.status.ok()) {
|
|
|
|
status = state.status;
|
2020-07-15 20:02:44 +02:00
|
|
|
io_s = state.io_status;
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
break;
|
|
|
|
}
|
2020-10-26 21:50:03 +01:00
|
|
|
|
|
|
|
if (!state.blob_file_additions.empty()) {
|
|
|
|
wrote_new_blob_files = true;
|
|
|
|
}
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
}
|
2020-10-26 21:50:03 +01:00
|
|
|
|
2020-07-15 20:02:44 +02:00
|
|
|
if (io_status_.ok()) {
|
|
|
|
io_status_ = io_s;
|
|
|
|
}
|
2020-10-26 21:50:03 +01:00
|
|
|
if (status.ok()) {
|
|
|
|
constexpr IODebugContext* dbg = nullptr;
|
|
|
|
|
|
|
|
if (output_directory_) {
|
|
|
|
io_s = output_directory_->Fsync(IOOptions(), dbg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (io_s.ok() && wrote_new_blob_files && blob_output_directory_ &&
|
|
|
|
blob_output_directory_ != output_directory_) {
|
|
|
|
io_s = blob_output_directory_->Fsync(IOOptions(), dbg);
|
|
|
|
}
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
if (io_status_.ok()) {
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
io_status_ = io_s;
|
2020-07-15 20:02:44 +02:00
|
|
|
}
|
|
|
|
if (status.ok()) {
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
status = io_s;
|
2018-09-14 22:17:12 +02:00
|
|
|
}
|
2018-06-15 21:28:06 +02:00
|
|
|
if (status.ok()) {
|
|
|
|
thread_pool.clear();
|
2020-07-22 20:03:29 +02:00
|
|
|
std::vector<const CompactionJob::SubcompactionState::Output*> files_output;
|
2018-06-15 21:28:06 +02:00
|
|
|
for (const auto& state : compact_->sub_compact_states) {
|
|
|
|
for (const auto& output : state.outputs) {
|
2020-07-22 20:03:29 +02:00
|
|
|
files_output.emplace_back(&output);
|
2018-06-15 21:28:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ColumnFamilyData* cfd = compact_->compaction->column_family_data();
|
|
|
|
auto prefix_extractor =
|
|
|
|
compact_->compaction->mutable_cf_options()->prefix_extractor.get();
|
2020-07-22 20:03:29 +02:00
|
|
|
std::atomic<size_t> next_file_idx(0);
|
2018-06-15 21:28:06 +02:00
|
|
|
auto verify_table = [&](Status& output_status) {
|
|
|
|
while (true) {
|
2020-07-22 20:03:29 +02:00
|
|
|
size_t file_idx = next_file_idx.fetch_add(1);
|
|
|
|
if (file_idx >= files_output.size()) {
|
2018-06-15 21:28:06 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Verify that the table is usable
|
|
|
|
// We set for_compaction to false and don't OptimizeForCompactionTableRead
|
|
|
|
// here because this is a special case after we finish the table building
|
|
|
|
// No matter whether use_direct_io_for_flush_and_compaction is true,
|
|
|
|
// we will regard this verification as user reads since the goal is
|
|
|
|
// to cache it here for further user reads
|
2020-08-04 00:21:56 +02:00
|
|
|
ReadOptions read_options;
|
2018-06-15 21:28:06 +02:00
|
|
|
InternalIterator* iter = cfd->table_cache()->NewIterator(
|
2020-08-04 00:21:56 +02:00
|
|
|
read_options, file_options_, cfd->internal_comparator(),
|
2020-07-22 20:03:29 +02:00
|
|
|
files_output[file_idx]->meta, /*range_del_agg=*/nullptr,
|
|
|
|
prefix_extractor,
|
2019-06-20 23:28:22 +02:00
|
|
|
/*table_reader_ptr=*/nullptr,
|
2018-06-15 21:28:06 +02:00
|
|
|
cfd->internal_stats()->GetFileReadHist(
|
|
|
|
compact_->compaction->output_level()),
|
2019-06-20 23:28:22 +02:00
|
|
|
TableReaderCaller::kCompactionRefill, /*arena=*/nullptr,
|
|
|
|
/*skip_filters=*/false, compact_->compaction->output_level(),
|
2020-06-10 01:49:07 +02:00
|
|
|
MaxFileSizeForL0MetaPin(
|
|
|
|
*compact_->compaction->mutable_cf_options()),
|
2019-06-20 23:28:22 +02:00
|
|
|
/*smallest_compaction_key=*/nullptr,
|
Properly report IO errors when IndexType::kBinarySearchWithFirstKey is used (#6621)
Summary:
Context: Index type `kBinarySearchWithFirstKey` added the ability for sst file iterator to sometimes report a key from index without reading the corresponding data block. This is useful when sst blocks are cut at some meaningful boundaries (e.g. one block per key prefix), and many seeks land between blocks (e.g. for each prefix, the ranges of keys in different sst files are nearly disjoint, so a typical seek needs to read a data block from only one file even if all files have the prefix). But this added a new error condition, which rocksdb code was really not equipped to deal with: `InternalIterator::value()` may fail with an IO error or Status::Incomplete, but it's just a method returning a Slice, with no way to report error instead. Before this PR, this type of error wasn't handled at all (an empty slice was returned), and kBinarySearchWithFirstKey implementation was considered a prototype.
Now that we (LogDevice) have experimented with kBinarySearchWithFirstKey for a while and confirmed that it's really useful, this PR is adding the missing error handling.
It's a pretty inconvenient situation implementation-wise. The error needs to be reported from InternalIterator when trying to access value. But there are ~700 call sites of `InternalIterator::value()`, most of which either can't hit the error condition (because the iterator is reading from memtable or from index or something) or wouldn't benefit from the deferred loading of the value (e.g. compaction iterator that reads all values anyway). Adding error handling to all these call sites would needlessly bloat the code. So instead I made the deferred value loading optional: only the call sites that may use deferred loading have to call the new method `PrepareValue()` before calling `value()`. The feature is enabled with a new bool argument `allow_unprepared_value` to a bunch of methods that create iterators (it wouldn't make sense to put it in ReadOptions because it's completely internal to iterators, with virtually no user-visible effect). Lmk if you have better ideas.
Note that the deferred value loading only happens for *internal* iterators. The user-visible iterator (DBIter) always prepares the value before returning from Seek/Next/etc. We could go further and add an API to defer that value loading too, but that's most likely not useful for LogDevice, so it doesn't seem worth the complexity for now.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6621
Test Plan: make -j5 check . Will also deploy to some logdevice test clusters and look at stats.
Reviewed By: siying
Differential Revision: D20786930
Pulled By: al13n321
fbshipit-source-id: 6da77d918bad3780522e918f17f4d5513d3e99ee
2020-04-16 02:37:23 +02:00
|
|
|
/*largest_compaction_key=*/nullptr,
|
|
|
|
/*allow_unprepared_value=*/false);
|
2018-06-15 21:28:06 +02:00
|
|
|
auto s = iter->status();
|
|
|
|
|
|
|
|
if (s.ok() && paranoid_file_checks_) {
|
2020-10-01 19:08:52 +02:00
|
|
|
OutputValidator validator(cfd->internal_comparator(),
|
|
|
|
/*_enable_order_check=*/true,
|
|
|
|
/*_enable_hash=*/true);
|
2020-07-22 20:03:29 +02:00
|
|
|
for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
|
2020-10-01 19:08:52 +02:00
|
|
|
s = validator.Add(iter->key(), iter->value());
|
|
|
|
if (!s.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
2020-07-22 20:03:29 +02:00
|
|
|
}
|
2020-10-01 19:08:52 +02:00
|
|
|
if (s.ok()) {
|
|
|
|
s = iter->status();
|
|
|
|
}
|
|
|
|
if (s.ok() &&
|
|
|
|
!validator.CompareValidator(files_output[file_idx]->validator)) {
|
2020-08-06 23:24:24 +02:00
|
|
|
s = Status::Corruption("Paranoid checksums do not match");
|
2020-07-22 20:03:29 +02:00
|
|
|
}
|
2018-06-15 21:28:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
delete iter;
|
|
|
|
|
|
|
|
if (!s.ok()) {
|
|
|
|
output_status = s;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
for (size_t i = 1; i < compact_->sub_compact_states.size(); i++) {
|
|
|
|
thread_pool.emplace_back(verify_table,
|
|
|
|
std::ref(compact_->sub_compact_states[i].status));
|
|
|
|
}
|
|
|
|
verify_table(compact_->sub_compact_states[0].status);
|
|
|
|
for (auto& thread : thread_pool) {
|
|
|
|
thread.join();
|
|
|
|
}
|
|
|
|
for (const auto& state : compact_->sub_compact_states) {
|
|
|
|
if (!state.status.ok()) {
|
|
|
|
status = state.status;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-15 18:03:08 +02:00
|
|
|
TablePropertiesCollection tp;
|
|
|
|
for (const auto& state : compact_->sub_compact_states) {
|
|
|
|
for (const auto& output : state.outputs) {
|
2018-04-13 02:55:14 +02:00
|
|
|
auto fn =
|
|
|
|
TableFileName(state.compaction->immutable_cf_options()->cf_paths,
|
|
|
|
output.meta.fd.GetNumber(), output.meta.fd.GetPathId());
|
2015-09-15 18:03:08 +02:00
|
|
|
tp[fn] = output.table_properties;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
compact_->compaction->SetOutputTableProperties(std::move(tp));
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
// Finish up all book-keeping to unify the subcompaction results
|
|
|
|
AggregateStatistics();
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
UpdateCompactionStats();
|
2020-10-26 21:50:03 +01:00
|
|
|
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
RecordCompactionIOStats();
|
|
|
|
LogFlush(db_options_.info_log);
|
|
|
|
TEST_SYNC_POINT("CompactionJob::Run():End");
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
compact_->status = status;
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2016-02-18 00:20:23 +01:00
|
|
|
Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(compact_);
|
|
|
|
|
2015-03-13 18:45:40 +01:00
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_INSTALL);
|
2016-02-18 00:20:23 +01:00
|
|
|
db_mutex_->AssertHeld();
|
2015-08-18 20:06:23 +02:00
|
|
|
Status status = compact_->status;
|
2020-10-26 21:50:03 +01:00
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
ColumnFamilyData* cfd = compact_->compaction->column_family_data();
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(cfd);
|
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
cfd->internal_stats()->AddCompactionStats(
|
2019-03-20 01:24:09 +01:00
|
|
|
compact_->compaction->output_level(), thread_pri_, compaction_stats_);
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
if (status.ok()) {
|
2016-02-18 00:20:23 +01:00
|
|
|
status = InstallCompactionResults(mutable_cf_options);
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
if (!versions_->io_status().ok()) {
|
|
|
|
io_status_ = versions_->io_status();
|
|
|
|
}
|
2020-10-26 21:50:03 +01:00
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
VersionStorageInfo::LevelSummaryStorage tmp;
|
Include bunch of more events into EventLogger
Summary:
Added these events:
* Recovery start, finish and also when recovery creates a file
* Trivial move
* Compaction start, finish and when compaction creates a file
* Flush start, finish
Also includes small fix to EventLogger
Also added option ROCKSDB_PRINT_EVENTS_TO_STDOUT which is useful when we debug things. I've spent far too much time chasing LOG files.
Still didn't get sst table properties in JSON. They are written very deeply into the stack. I'll address in separate diff.
TODO:
* Write specification. Let's first use this for a while and figure out what's good data to put here, too. After that we'll write spec
* Write tools that parse and analyze LOGs. This can be in python or go. Good intern task.
Test Plan: Ran db_bench with ROCKSDB_PRINT_EVENTS_TO_STDOUT. Here's the output: https://phabricator.fb.com/P19811976
Reviewers: sdong, yhchiang, rven, MarkCallaghan, kradhakrishnan, anthony
Reviewed By: anthony
Subscribers: dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D37521
2015-04-28 00:20:02 +02:00
|
|
|
auto vstorage = cfd->current()->storage_info();
|
2014-11-01 00:31:25 +01:00
|
|
|
const auto& stats = compaction_stats_;
|
2016-11-29 01:39:49 +01:00
|
|
|
|
|
|
|
double read_write_amp = 0.0;
|
|
|
|
double write_amp = 0.0;
|
2017-07-24 20:53:03 +02:00
|
|
|
double bytes_read_per_sec = 0;
|
|
|
|
double bytes_written_per_sec = 0;
|
|
|
|
|
2021-03-04 09:42:11 +01:00
|
|
|
const uint64_t bytes_read_non_output_and_blob =
|
|
|
|
stats.bytes_read_non_output_levels + stats.bytes_read_blob;
|
|
|
|
const uint64_t bytes_read_all =
|
|
|
|
stats.bytes_read_output_level + bytes_read_non_output_and_blob;
|
|
|
|
const uint64_t bytes_written_all =
|
|
|
|
stats.bytes_written + stats.bytes_written_blob;
|
|
|
|
|
|
|
|
if (bytes_read_non_output_and_blob > 0) {
|
|
|
|
read_write_amp = (bytes_written_all + bytes_read_all) /
|
|
|
|
static_cast<double>(bytes_read_non_output_and_blob);
|
|
|
|
write_amp =
|
|
|
|
bytes_written_all / static_cast<double>(bytes_read_non_output_and_blob);
|
2016-11-29 01:39:49 +01:00
|
|
|
}
|
2017-07-24 20:53:03 +02:00
|
|
|
if (stats.micros > 0) {
|
2021-03-04 09:42:11 +01:00
|
|
|
bytes_read_per_sec = bytes_read_all / static_cast<double>(stats.micros);
|
|
|
|
bytes_written_per_sec =
|
|
|
|
bytes_written_all / static_cast<double>(stats.micros);
|
2017-07-24 20:53:03 +02:00
|
|
|
}
|
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
const std::string& column_family_name = cfd->GetName();
|
|
|
|
|
2021-03-02 18:46:10 +01:00
|
|
|
constexpr double kMB = 1048576.0;
|
|
|
|
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_BUFFER(
|
2015-06-18 08:40:34 +02:00
|
|
|
log_buffer_,
|
|
|
|
"[%s] compacted to: %s, MB/sec: %.1f rd, %.1f wr, level %d, "
|
2021-03-02 18:46:10 +01:00
|
|
|
"files in(%d, %d) out(%d +%d blob) "
|
2021-03-04 09:42:11 +01:00
|
|
|
"MB in(%.1f, %.1f +%.1f blob) out(%.1f +%.1f blob), "
|
|
|
|
"read-write-amplify(%.1f) write-amplify(%.1f) %s, records in: %" PRIu64
|
2018-01-09 23:46:30 +01:00
|
|
|
", records dropped: %" PRIu64 " output_compression: %s\n",
|
2020-10-26 21:50:03 +01:00
|
|
|
column_family_name.c_str(), vstorage->LevelSummary(&tmp),
|
|
|
|
bytes_read_per_sec, bytes_written_per_sec,
|
|
|
|
compact_->compaction->output_level(),
|
2015-06-18 08:40:34 +02:00
|
|
|
stats.num_input_files_in_non_output_levels,
|
2016-11-29 01:39:49 +01:00
|
|
|
stats.num_input_files_in_output_level, stats.num_output_files,
|
2021-03-02 18:46:10 +01:00
|
|
|
stats.num_output_files_blob, stats.bytes_read_non_output_levels / kMB,
|
2021-03-04 09:42:11 +01:00
|
|
|
stats.bytes_read_output_level / kMB, stats.bytes_read_blob / kMB,
|
|
|
|
stats.bytes_written / kMB, stats.bytes_written_blob / kMB, read_write_amp,
|
|
|
|
write_amp, status.ToString().c_str(), stats.num_input_records,
|
2017-12-14 19:18:01 +01:00
|
|
|
stats.num_dropped_records,
|
|
|
|
CompressionTypeToString(compact_->compaction->output_compression())
|
|
|
|
.c_str());
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
const auto& blob_files = vstorage->GetBlobFiles();
|
|
|
|
if (!blob_files.empty()) {
|
|
|
|
ROCKS_LOG_BUFFER(log_buffer_,
|
|
|
|
"[%s] Blob file summary: head=%" PRIu64 ", tail=%" PRIu64
|
|
|
|
"\n",
|
|
|
|
column_family_name.c_str(), blob_files.begin()->first,
|
|
|
|
blob_files.rbegin()->first);
|
|
|
|
}
|
|
|
|
|
2015-06-03 02:07:16 +02:00
|
|
|
UpdateCompactionJobStats(stats);
|
|
|
|
|
Include bunch of more events into EventLogger
Summary:
Added these events:
* Recovery start, finish and also when recovery creates a file
* Trivial move
* Compaction start, finish and when compaction creates a file
* Flush start, finish
Also includes small fix to EventLogger
Also added option ROCKSDB_PRINT_EVENTS_TO_STDOUT which is useful when we debug things. I've spent far too much time chasing LOG files.
Still didn't get sst table properties in JSON. They are written very deeply into the stack. I'll address in separate diff.
TODO:
* Write specification. Let's first use this for a while and figure out what's good data to put here, too. After that we'll write spec
* Write tools that parse and analyze LOGs. This can be in python or go. Good intern task.
Test Plan: Ran db_bench with ROCKSDB_PRINT_EVENTS_TO_STDOUT. Here's the output: https://phabricator.fb.com/P19811976
Reviewers: sdong, yhchiang, rven, MarkCallaghan, kradhakrishnan, anthony
Reviewed By: anthony
Subscribers: dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D37521
2015-04-28 00:20:02 +02:00
|
|
|
auto stream = event_logger_->LogToBuffer(log_buffer_);
|
2017-12-14 19:18:01 +01:00
|
|
|
stream << "job" << job_id_ << "event"
|
|
|
|
<< "compaction_finished"
|
2020-01-24 00:25:23 +01:00
|
|
|
<< "compaction_time_micros" << stats.micros
|
|
|
|
<< "compaction_time_cpu_micros" << stats.cpu_micros << "output_level"
|
|
|
|
<< compact_->compaction->output_level() << "num_output_files"
|
2020-10-26 21:50:03 +01:00
|
|
|
<< compact_->num_output_files << "total_output_size"
|
|
|
|
<< compact_->total_bytes;
|
|
|
|
|
|
|
|
if (compact_->num_blob_output_files > 0) {
|
|
|
|
stream << "num_blob_output_files" << compact_->num_blob_output_files
|
|
|
|
<< "total_blob_output_size" << compact_->total_blob_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
stream << "num_input_records" << stats.num_input_records
|
|
|
|
<< "num_output_records" << compact_->num_output_records
|
|
|
|
<< "num_subcompactions" << compact_->sub_compact_states.size()
|
|
|
|
<< "output_compression"
|
2017-12-14 19:18:01 +01:00
|
|
|
<< CompressionTypeToString(compact_->compaction->output_compression());
|
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
|
|
|
|
2020-10-01 21:51:33 +02:00
|
|
|
stream << "num_single_delete_mismatches"
|
|
|
|
<< compaction_job_stats_->num_single_del_mismatch;
|
|
|
|
stream << "num_single_delete_fallthrough"
|
|
|
|
<< compaction_job_stats_->num_single_del_fallthru;
|
2016-08-16 17:21:43 +02:00
|
|
|
|
2020-10-01 21:51:33 +02:00
|
|
|
if (measure_io_stats_) {
|
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
|
|
|
stream << "file_write_nanos" << compaction_job_stats_->file_write_nanos;
|
|
|
|
stream << "file_range_sync_nanos"
|
|
|
|
<< compaction_job_stats_->file_range_sync_nanos;
|
|
|
|
stream << "file_fsync_nanos" << compaction_job_stats_->file_fsync_nanos;
|
|
|
|
stream << "file_prepare_write_nanos"
|
|
|
|
<< compaction_job_stats_->file_prepare_write_nanos;
|
|
|
|
}
|
|
|
|
|
Include bunch of more events into EventLogger
Summary:
Added these events:
* Recovery start, finish and also when recovery creates a file
* Trivial move
* Compaction start, finish and when compaction creates a file
* Flush start, finish
Also includes small fix to EventLogger
Also added option ROCKSDB_PRINT_EVENTS_TO_STDOUT which is useful when we debug things. I've spent far too much time chasing LOG files.
Still didn't get sst table properties in JSON. They are written very deeply into the stack. I'll address in separate diff.
TODO:
* Write specification. Let's first use this for a while and figure out what's good data to put here, too. After that we'll write spec
* Write tools that parse and analyze LOGs. This can be in python or go. Good intern task.
Test Plan: Ran db_bench with ROCKSDB_PRINT_EVENTS_TO_STDOUT. Here's the output: https://phabricator.fb.com/P19811976
Reviewers: sdong, yhchiang, rven, MarkCallaghan, kradhakrishnan, anthony
Reviewed By: anthony
Subscribers: dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D37521
2015-04-28 00:20:02 +02:00
|
|
|
stream << "lsm_state";
|
|
|
|
stream.StartArray();
|
|
|
|
for (int level = 0; level < vstorage->num_levels(); ++level) {
|
|
|
|
stream << vstorage->NumLevelFiles(level);
|
|
|
|
}
|
|
|
|
stream.EndArray();
|
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
if (!blob_files.empty()) {
|
|
|
|
stream << "blob_file_head" << blob_files.begin()->first;
|
|
|
|
stream << "blob_file_tail" << blob_files.rbegin()->first;
|
|
|
|
}
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
CleanupCompaction();
|
|
|
|
return status;
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
|
2021-05-20 06:40:43 +02:00
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
void CompactionJob::ProcessKeyValueCompactionWithCompactionService(
|
|
|
|
SubcompactionState* sub_compact) {
|
|
|
|
assert(sub_compact);
|
|
|
|
assert(sub_compact->compaction);
|
|
|
|
assert(db_options_.compaction_service);
|
|
|
|
|
|
|
|
const Compaction* compaction = sub_compact->compaction;
|
|
|
|
CompactionServiceInput compaction_input;
|
|
|
|
compaction_input.output_level = compaction->output_level();
|
|
|
|
|
|
|
|
const std::vector<CompactionInputFiles>& inputs =
|
|
|
|
*(compact_->compaction->inputs());
|
|
|
|
for (const auto& files_per_level : inputs) {
|
|
|
|
for (const auto& file : files_per_level.files) {
|
|
|
|
compaction_input.input_files.emplace_back(
|
|
|
|
MakeTableFileName(file->fd.GetNumber()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
compaction_input.column_family.name =
|
|
|
|
compaction->column_family_data()->GetName();
|
|
|
|
compaction_input.column_family.options =
|
|
|
|
compaction->column_family_data()->GetLatestCFOptions();
|
|
|
|
compaction_input.db_options =
|
|
|
|
BuildDBOptions(db_options_, mutable_db_options_copy_);
|
|
|
|
compaction_input.snapshots = existing_snapshots_;
|
|
|
|
compaction_input.has_begin = sub_compact->start;
|
|
|
|
compaction_input.begin =
|
|
|
|
compaction_input.has_begin ? sub_compact->start->ToString() : "";
|
|
|
|
compaction_input.has_end = sub_compact->end;
|
|
|
|
compaction_input.end =
|
|
|
|
compaction_input.has_end ? sub_compact->end->ToString() : "";
|
|
|
|
compaction_input.approx_size = sub_compact->approx_size;
|
|
|
|
|
|
|
|
std::string compaction_input_binary;
|
|
|
|
Status s = compaction_input.Write(&compaction_input_binary);
|
|
|
|
if (!s.ok()) {
|
|
|
|
sub_compact->status = s;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::ostringstream input_files_oss;
|
|
|
|
bool is_first_one = true;
|
|
|
|
for (const auto& file : compaction_input.input_files) {
|
|
|
|
input_files_oss << (is_first_one ? "" : ", ") << file;
|
|
|
|
is_first_one = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ROCKS_LOG_INFO(
|
|
|
|
db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Starting remote compaction (output level: %d): %s",
|
|
|
|
compaction_input.column_family.name.c_str(), job_id_,
|
|
|
|
compaction_input.output_level, input_files_oss.str().c_str());
|
|
|
|
CompactionServiceJobStatus compaction_status =
|
|
|
|
db_options_.compaction_service->Start(compaction_input_binary, job_id_);
|
|
|
|
if (compaction_status != CompactionServiceJobStatus::kSuccess) {
|
|
|
|
sub_compact->status =
|
|
|
|
Status::Incomplete("CompactionService failed to start compaction job.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string compaction_result_binary;
|
|
|
|
compaction_status = db_options_.compaction_service->WaitForComplete(
|
|
|
|
job_id_, &compaction_result_binary);
|
|
|
|
|
|
|
|
CompactionServiceResult compaction_result;
|
|
|
|
s = CompactionServiceResult::Read(compaction_result_binary,
|
|
|
|
&compaction_result);
|
|
|
|
if (compaction_status != CompactionServiceJobStatus::kSuccess) {
|
|
|
|
sub_compact->status =
|
|
|
|
s.ok() ? compaction_result.status
|
|
|
|
: Status::Incomplete(
|
|
|
|
"CompactionService failed to run compaction job.");
|
|
|
|
compaction_result.status.PermitUncheckedError();
|
|
|
|
ROCKS_LOG_WARN(db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Remote compaction failed, status: %s",
|
|
|
|
compaction_input.column_family.name.c_str(), job_id_,
|
|
|
|
s.ToString().c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!s.ok()) {
|
|
|
|
sub_compact->status = s;
|
|
|
|
compaction_result.status.PermitUncheckedError();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sub_compact->status = compaction_result.status;
|
|
|
|
|
|
|
|
std::ostringstream output_files_oss;
|
|
|
|
is_first_one = true;
|
|
|
|
for (const auto& file : compaction_result.output_files) {
|
|
|
|
output_files_oss << (is_first_one ? "" : ", ") << file.file_name;
|
|
|
|
is_first_one = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ROCKS_LOG_INFO(db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Receive remote compaction result, output path: "
|
|
|
|
"%s, files: %s",
|
|
|
|
compaction_input.column_family.name.c_str(), job_id_,
|
|
|
|
compaction_result.output_path.c_str(),
|
|
|
|
output_files_oss.str().c_str());
|
|
|
|
|
|
|
|
if (!s.ok()) {
|
|
|
|
sub_compact->status = s;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto& file : compaction_result.output_files) {
|
|
|
|
uint64_t file_num = versions_->NewFileNumber();
|
|
|
|
auto src_file = compaction_result.output_path + "/" + file.file_name;
|
|
|
|
auto tgt_file = TableFileName(compaction->immutable_cf_options()->cf_paths,
|
|
|
|
file_num, compaction->output_path_id());
|
|
|
|
s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr);
|
|
|
|
if (!s.ok()) {
|
|
|
|
sub_compact->status = s;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
FileMetaData meta;
|
|
|
|
uint64_t file_size;
|
|
|
|
s = fs_->GetFileSize(tgt_file, IOOptions(), &file_size, nullptr);
|
|
|
|
if (!s.ok()) {
|
|
|
|
sub_compact->status = s;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
meta.fd = FileDescriptor(file_num, compaction->output_path_id(), file_size,
|
|
|
|
file.smallest_seqno, file.largest_seqno);
|
|
|
|
meta.smallest.DecodeFrom(file.smallest_internal_key);
|
|
|
|
meta.largest.DecodeFrom(file.largest_internal_key);
|
|
|
|
meta.oldest_ancester_time = file.oldest_ancester_time;
|
|
|
|
meta.file_creation_time = file.file_creation_time;
|
|
|
|
meta.marked_for_compaction = file.marked_for_compaction;
|
|
|
|
|
|
|
|
auto cfd = compaction->column_family_data();
|
|
|
|
sub_compact->outputs.emplace_back(std::move(meta),
|
|
|
|
cfd->internal_comparator(), false, false,
|
|
|
|
true, file.paranoid_hash);
|
|
|
|
}
|
|
|
|
sub_compact->compaction_job_stats = compaction_result.stats;
|
|
|
|
sub_compact->num_output_records = compaction_result.num_output_records;
|
|
|
|
sub_compact->approx_size = compaction_input.approx_size; // is this used?
|
|
|
|
sub_compact->total_bytes = compaction_result.total_bytes;
|
|
|
|
IOSTATS_ADD(bytes_written, compaction_result.bytes_written);
|
|
|
|
IOSTATS_ADD(bytes_read, compaction_result.bytes_read);
|
|
|
|
}
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(sub_compact);
|
|
|
|
assert(sub_compact->compaction);
|
2019-01-30 01:23:21 +01:00
|
|
|
|
2021-05-20 06:40:43 +02:00
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
if (db_options_.compaction_service) {
|
|
|
|
return ProcessKeyValueCompactionWithCompactionService(sub_compact);
|
|
|
|
}
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
|
2021-03-15 12:32:24 +01:00
|
|
|
uint64_t prev_cpu_micros = db_options_.clock->CPUNanos() / 1000;
|
2019-01-30 01:23:21 +01:00
|
|
|
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
|
2019-02-08 01:16:48 +01:00
|
|
|
|
|
|
|
// Create compaction filter and fail the compaction if
|
|
|
|
// IgnoreSnapshots() = false because it is not supported anymore
|
|
|
|
const CompactionFilter* compaction_filter =
|
|
|
|
cfd->ioptions()->compaction_filter;
|
|
|
|
std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
|
|
|
|
if (compaction_filter == nullptr) {
|
|
|
|
compaction_filter_from_factory =
|
|
|
|
sub_compact->compaction->CreateCompactionFilter();
|
|
|
|
compaction_filter = compaction_filter_from_factory.get();
|
|
|
|
}
|
|
|
|
if (compaction_filter != nullptr && !compaction_filter->IgnoreSnapshots()) {
|
|
|
|
sub_compact->status = Status::NotSupported(
|
|
|
|
"CompactionFilter::IgnoreSnapshots() = false is not supported "
|
|
|
|
"anymore.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-12-18 02:26:56 +01:00
|
|
|
CompactionRangeDelAggregator range_del_agg(&cfd->internal_comparator(),
|
|
|
|
existing_snapshots_);
|
2021-06-10 00:40:16 +02:00
|
|
|
|
|
|
|
const Slice* const start = sub_compact->start;
|
|
|
|
const Slice* const end = sub_compact->end;
|
|
|
|
|
2020-08-04 00:21:56 +02:00
|
|
|
ReadOptions read_options;
|
|
|
|
read_options.verify_checksums = true;
|
|
|
|
read_options.fill_cache = false;
|
|
|
|
// Compaction iterators shouldn't be confined to a single prefix.
|
|
|
|
// Compactions use Seek() for
|
|
|
|
// (a) concurrent compactions,
|
|
|
|
// (b) CompactionFilter::Decision::kRemoveAndSkipUntil.
|
|
|
|
read_options.total_order_seek = true;
|
2021-06-12 21:08:30 +02:00
|
|
|
|
|
|
|
// Note: if we're going to support subcompactions for user-defined timestamps,
|
|
|
|
// the timestamp part will have to be stripped from the bounds here.
|
|
|
|
assert((!start && !end) || cfd->user_comparator()->timestamp_size() == 0);
|
2021-06-10 00:40:16 +02:00
|
|
|
read_options.iterate_lower_bound = start;
|
|
|
|
read_options.iterate_upper_bound = end;
|
2018-11-21 19:53:44 +01:00
|
|
|
|
|
|
|
// Although the v2 aggregator is what the level iterator(s) know about,
|
|
|
|
// the AddTombstones calls will be propagated down to the v1 aggregator.
|
2021-06-10 00:40:16 +02:00
|
|
|
std::unique_ptr<InternalIterator> raw_input(
|
2020-08-04 00:21:56 +02:00
|
|
|
versions_->MakeInputIterator(read_options, sub_compact->compaction,
|
|
|
|
&range_del_agg, file_options_for_read_));
|
2021-06-10 00:40:16 +02:00
|
|
|
InternalIterator* input = raw_input.get();
|
|
|
|
|
|
|
|
IterKey start_ikey;
|
|
|
|
IterKey end_ikey;
|
|
|
|
Slice start_slice;
|
|
|
|
Slice end_slice;
|
|
|
|
|
|
|
|
if (start) {
|
|
|
|
start_ikey.SetInternalKey(*start, kMaxSequenceNumber, kValueTypeForSeek);
|
|
|
|
start_slice = start_ikey.GetInternalKey();
|
|
|
|
}
|
|
|
|
if (end) {
|
|
|
|
end_ikey.SetInternalKey(*end, kMaxSequenceNumber, kValueTypeForSeek);
|
|
|
|
end_slice = end_ikey.GetInternalKey();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<InternalIterator> clip;
|
|
|
|
if (start || end) {
|
|
|
|
clip.reset(new ClippingIterator(
|
|
|
|
raw_input.get(), start ? &start_slice : nullptr,
|
|
|
|
end ? &end_slice : nullptr, &cfd->internal_comparator()));
|
|
|
|
input = clip.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
input->SeekToFirst();
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-03-13 18:45:40 +01:00
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_PROCESS_KV);
|
2015-08-18 20:06:23 +02:00
|
|
|
|
|
|
|
// I/O measurement variables
|
|
|
|
PerfLevel prev_perf_level = PerfLevel::kEnableTime;
|
2015-09-10 23:35:25 +02:00
|
|
|
const uint64_t kRecordStatsEvery = 1000;
|
2015-08-18 20:06:23 +02:00
|
|
|
uint64_t prev_write_nanos = 0;
|
|
|
|
uint64_t prev_fsync_nanos = 0;
|
|
|
|
uint64_t prev_range_sync_nanos = 0;
|
|
|
|
uint64_t prev_prepare_write_nanos = 0;
|
2019-01-30 01:23:21 +01:00
|
|
|
uint64_t prev_cpu_write_nanos = 0;
|
|
|
|
uint64_t prev_cpu_read_nanos = 0;
|
2015-08-18 20:06:23 +02:00
|
|
|
if (measure_io_stats_) {
|
|
|
|
prev_perf_level = GetPerfLevel();
|
2019-01-30 01:23:21 +01:00
|
|
|
SetPerfLevel(PerfLevel::kEnableTimeAndCPUTimeExceptForMutex);
|
2015-10-19 22:40:44 +02:00
|
|
|
prev_write_nanos = IOSTATS(write_nanos);
|
|
|
|
prev_fsync_nanos = IOSTATS(fsync_nanos);
|
|
|
|
prev_range_sync_nanos = IOSTATS(range_sync_nanos);
|
|
|
|
prev_prepare_write_nanos = IOSTATS(prepare_write_nanos);
|
2019-01-30 01:23:21 +01:00
|
|
|
prev_cpu_write_nanos = IOSTATS(cpu_write_nanos);
|
|
|
|
prev_cpu_read_nanos = IOSTATS(cpu_read_nanos);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
|
|
|
|
Compaction filter on merge operands
Summary:
Since Andres' internship is over, I took over https://reviews.facebook.net/D42555 and rebased and simplified it a bit.
The behavior in this diff is a bit simpler than in D42555:
* only merge operators are passed through FilterMergeValue(). If fitler function returns true, the merge operator is ignored
* compaction filter is *not* called on: 1) results of merge operations and 2) base values that are getting merged with merge operands (the second case was also true in previous diff)
Do we also need a compaction filter to get called on merge results?
Test Plan: make && make check
Reviewers: lovro, tnovak, rven, yhchiang, sdong
Reviewed By: sdong
Subscribers: noetzli, kolmike, leveldb, dhruba, sdong
Differential Revision: https://reviews.facebook.net/D47847
2015-10-07 18:30:03 +02:00
|
|
|
MergeHelper merge(
|
2021-04-23 05:42:50 +02:00
|
|
|
env_, cfd->user_comparator(), cfd->ioptions()->merge_operator.get(),
|
Compaction filter on merge operands
Summary:
Since Andres' internship is over, I took over https://reviews.facebook.net/D42555 and rebased and simplified it a bit.
The behavior in this diff is a bit simpler than in D42555:
* only merge operators are passed through FilterMergeValue(). If fitler function returns true, the merge operator is ignored
* compaction filter is *not* called on: 1) results of merge operations and 2) base values that are getting merged with merge operands (the second case was also true in previous diff)
Do we also need a compaction filter to get called on merge results?
Test Plan: make && make check
Reviewers: lovro, tnovak, rven, yhchiang, sdong
Reviewed By: sdong
Subscribers: noetzli, kolmike, leveldb, dhruba, sdong
Differential Revision: https://reviews.facebook.net/D47847
2015-10-07 18:30:03 +02:00
|
|
|
compaction_filter, db_options_.info_log.get(),
|
|
|
|
false /* internal key corruption is expected */,
|
|
|
|
existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
|
2021-05-05 22:59:21 +02:00
|
|
|
snapshot_checker_, compact_->compaction->level(), db_options_.stats);
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
const MutableCFOptions* mutable_cf_options =
|
|
|
|
sub_compact->compaction->mutable_cf_options();
|
|
|
|
assert(mutable_cf_options);
|
|
|
|
|
|
|
|
std::vector<std::string> blob_file_paths;
|
|
|
|
|
|
|
|
std::unique_ptr<BlobFileBuilder> blob_file_builder(
|
|
|
|
mutable_cf_options->enable_blob_files
|
2021-03-18 04:43:22 +01:00
|
|
|
? new BlobFileBuilder(versions_, fs_.get(),
|
|
|
|
sub_compact->compaction->immutable_cf_options(),
|
|
|
|
mutable_cf_options, &file_options_, job_id_,
|
|
|
|
cfd->GetID(), cfd->GetName(),
|
|
|
|
Env::IOPriority::IO_LOW, write_hint_,
|
|
|
|
io_tracer_, blob_callback_, &blob_file_paths,
|
|
|
|
&sub_compact->blob_file_additions)
|
2020-10-26 21:50:03 +01:00
|
|
|
: nullptr);
|
|
|
|
|
2015-03-14 16:21:53 +01:00
|
|
|
TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
|
2019-09-19 21:32:33 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK(
|
|
|
|
"CompactionJob::Run():PausingManualCompaction:1",
|
|
|
|
reinterpret_cast<void*>(
|
2020-08-14 20:28:12 +02:00
|
|
|
const_cast<std::atomic<int>*>(manual_compaction_paused_)));
|
2015-03-11 18:31:02 +01:00
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
Status status;
|
2020-11-12 20:40:52 +01:00
|
|
|
const std::string* const full_history_ts_low =
|
|
|
|
full_history_ts_low_.empty() ? nullptr : &full_history_ts_low_;
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->c_iter.reset(new CompactionIterator(
|
2021-06-10 00:40:16 +02:00
|
|
|
input, cfd->user_comparator(), &merge, versions_->LastSequence(),
|
2017-10-06 19:26:38 +02:00
|
|
|
&existing_snapshots_, earliest_write_conflict_snapshot_,
|
2020-07-15 02:16:18 +02:00
|
|
|
snapshot_checker_, env_, ShouldReportDetailedTime(env_, stats_),
|
|
|
|
/*expect_valid_internal_key=*/true, &range_del_agg,
|
2020-10-26 21:50:03 +01:00
|
|
|
blob_file_builder.get(), db_options_.allow_data_in_errors,
|
2020-09-30 08:16:12 +02:00
|
|
|
sub_compact->compaction, compaction_filter, shutting_down_,
|
2021-06-07 20:40:31 +02:00
|
|
|
preserve_deletes_seqnum_, manual_compaction_paused_,
|
|
|
|
manual_compaction_canceled_, db_options_.info_log, full_history_ts_low));
|
2015-09-10 23:35:25 +02:00
|
|
|
auto c_iter = sub_compact->c_iter.get();
|
|
|
|
c_iter->SeekToFirst();
|
2018-04-13 02:55:14 +02:00
|
|
|
if (c_iter->Valid() && sub_compact->compaction->output_level() != 0) {
|
2017-02-09 01:07:29 +01:00
|
|
|
// ShouldStopBefore() maintains state based on keys processed so far. The
|
|
|
|
// compaction loop always calls it on the "next" key, thus won't tell it the
|
|
|
|
// first key. So we do that here.
|
2018-04-13 02:55:14 +02:00
|
|
|
sub_compact->ShouldStopBefore(c_iter->key(),
|
|
|
|
sub_compact->current_output_file_size);
|
2017-02-09 01:07:29 +01:00
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
const auto& c_iter_stats = c_iter->iter_stats();
|
Shared dictionary compression using reference block
Summary:
This adds a new metablock containing a shared dictionary that is used
to compress all data blocks in the SST file. The size of the shared dictionary
is configurable in CompressionOptions and defaults to 0. It's currently only
used for zlib/lz4/lz4hc, but the block will be stored in the SST regardless of
the compression type if the user chooses a nonzero dictionary size.
During compaction, computes the dictionary by randomly sampling the first
output file in each subcompaction. It pre-computes the intervals to sample
by assuming the output file will have the maximum allowable length. In case
the file is smaller, some of the pre-computed sampling intervals can be beyond
end-of-file, in which case we skip over those samples and the dictionary will
be a bit smaller. After the dictionary is generated using the first file in a
subcompaction, it is loaded into the compression library before writing each
block in each subsequent file of that subcompaction.
On the read path, gets the dictionary from the metablock, if it exists. Then,
loads that dictionary into the compression library before reading each block.
Test Plan: new unit test
Reviewers: yhchiang, IslamAbdelRahman, cyan, sdong
Reviewed By: sdong
Subscribers: andrewkr, yoshinorim, kradhakrishnan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D52287
2016-04-28 02:36:03 +02:00
|
|
|
|
2020-07-24 22:43:14 +02:00
|
|
|
std::unique_ptr<SstPartitioner> partitioner =
|
|
|
|
sub_compact->compaction->output_level() == 0
|
|
|
|
? nullptr
|
|
|
|
: sub_compact->compaction->CreateSstPartitioner();
|
|
|
|
std::string last_key_for_partitioner;
|
|
|
|
|
2017-01-12 00:01:21 +01:00
|
|
|
while (status.ok() && !cfd->IsDropped() && c_iter->Valid()) {
|
2015-09-10 23:35:25 +02:00
|
|
|
// Invariant: c_iter.status() is guaranteed to be OK if c_iter->Valid()
|
|
|
|
// returns true.
|
|
|
|
const Slice& key = c_iter->key();
|
|
|
|
const Slice& value = c_iter->value();
|
Parallelize L0-L1 Compaction: Restructure Compaction Job
Summary:
As of now compactions involving files from Level 0 and Level 1 are single
threaded because the files in L0, although sorted, are not range partitioned like
the other levels. This means that during L0-L1 compaction each file from L1
needs to be merged with potentially all the files from L0.
This attempt to parallelize the L0-L1 compaction assigns a thread and a
corresponding iterator to each L1 file that then considers only the key range
found in that L1 file and only the L0 files that have those keys (and only the
specific portion of those L0 files in which those keys are found). In this way
the overlap is minimized and potentially eliminated between different iterators
focusing on the same files.
The first step is to restructure the compaction logic to break L0-L1 compactions
into multiple, smaller, sequential compactions. Eventually each of these smaller
jobs will be run simultaneously. Areas to pay extra attention to are
# Correct aggregation of compaction job statistics across multiple threads
# Proper opening/closing of output files (make sure each thread's is unique)
# Keys that span multiple L1 files
# Skewed distributions of keys within L0 files
Test Plan: Make and run db_test (newer version has separate compaction tests) and compaction_job_stats_test
Reviewers: igor, noetzli, anthony, sdong, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D42699
2015-08-03 20:32:14 +02:00
|
|
|
|
2021-06-10 00:40:16 +02:00
|
|
|
assert(!end ||
|
|
|
|
cfd->user_comparator()->Compare(c_iter->user_key(), *end) < 0);
|
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
if (c_iter_stats.num_input_records % kRecordStatsEvery ==
|
|
|
|
kRecordStatsEvery - 1) {
|
|
|
|
RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
|
|
|
|
c_iter->ResetRecordCounts();
|
|
|
|
RecordCompactionIOStats();
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
// Open output file if necessary
|
|
|
|
if (sub_compact->builder == nullptr) {
|
|
|
|
status = OpenCompactionOutputFile(sub_compact);
|
|
|
|
if (!status.ok()) {
|
2015-07-29 04:21:55 +02:00
|
|
|
break;
|
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
}
|
2020-10-01 19:08:52 +02:00
|
|
|
status = sub_compact->AddToBuilder(key, value);
|
|
|
|
if (!status.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
2020-07-22 20:03:29 +02:00
|
|
|
|
2020-04-02 01:37:54 +02:00
|
|
|
sub_compact->current_output_file_size =
|
|
|
|
sub_compact->builder->EstimatedFileSize();
|
2019-10-15 00:19:31 +02:00
|
|
|
const ParsedInternalKey& ikey = c_iter->ikey();
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->current_output()->meta.UpdateBoundaries(
|
2019-10-15 00:19:31 +02:00
|
|
|
key, value, ikey.sequence, ikey.type);
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->num_output_records++;
|
|
|
|
|
2017-02-09 01:07:29 +01:00
|
|
|
// Close output file if it is big enough. Two possibilities determine it's
|
|
|
|
// time to close it: (1) the current key should be this file's last key, (2)
|
|
|
|
// the next key should not be in this file.
|
|
|
|
//
|
2015-09-10 23:35:25 +02:00
|
|
|
// TODO(aekmekji): determine if file should be closed earlier than this
|
|
|
|
// during subcompactions (i.e. if output size, estimated by input size, is
|
|
|
|
// going to be 1.2MB and max_output_file_size = 1MB, prefer to have 0.6MB
|
|
|
|
// and 0.6MB instead of 1MB and 0.2MB)
|
2017-02-09 01:07:29 +01:00
|
|
|
bool output_file_ended = false;
|
2016-10-19 01:30:34 +02:00
|
|
|
if (sub_compact->compaction->output_level() != 0 &&
|
|
|
|
sub_compact->current_output_file_size >=
|
|
|
|
sub_compact->compaction->max_output_file_size()) {
|
2017-02-09 01:07:29 +01:00
|
|
|
// (1) this key terminates the file. For historical reasons, the iterator
|
|
|
|
// status before advancing will be given to FinishCompactionOutputFile().
|
|
|
|
output_file_ended = true;
|
|
|
|
}
|
2019-09-19 21:32:33 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK(
|
|
|
|
"CompactionJob::Run():PausingManualCompaction:2",
|
|
|
|
reinterpret_cast<void*>(
|
2020-08-14 20:28:12 +02:00
|
|
|
const_cast<std::atomic<int>*>(manual_compaction_paused_)));
|
2020-07-24 22:43:14 +02:00
|
|
|
if (partitioner.get()) {
|
|
|
|
last_key_for_partitioner.assign(c_iter->user_key().data_,
|
|
|
|
c_iter->user_key().size_);
|
|
|
|
}
|
2017-02-09 01:07:29 +01:00
|
|
|
c_iter->Next();
|
2019-09-17 06:00:13 +02:00
|
|
|
if (c_iter->status().IsManualCompactionPaused()) {
|
|
|
|
break;
|
|
|
|
}
|
2020-07-24 22:43:14 +02:00
|
|
|
if (!output_file_ended && c_iter->Valid()) {
|
|
|
|
if (((partitioner.get() &&
|
|
|
|
partitioner->ShouldPartition(PartitionerRequest(
|
|
|
|
last_key_for_partitioner, c_iter->user_key(),
|
|
|
|
sub_compact->current_output_file_size)) == kRequired) ||
|
|
|
|
(sub_compact->compaction->output_level() != 0 &&
|
|
|
|
sub_compact->ShouldStopBefore(
|
|
|
|
c_iter->key(), sub_compact->current_output_file_size))) &&
|
|
|
|
sub_compact->builder != nullptr) {
|
|
|
|
// (2) this key belongs to the next file. For historical reasons, the
|
|
|
|
// iterator status after advancing will be given to
|
|
|
|
// FinishCompactionOutputFile().
|
|
|
|
output_file_ended = true;
|
|
|
|
}
|
2017-02-09 01:07:29 +01:00
|
|
|
}
|
|
|
|
if (output_file_ended) {
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
const Slice* next_key = nullptr;
|
|
|
|
if (c_iter->Valid()) {
|
|
|
|
next_key = &c_iter->key();
|
|
|
|
}
|
2016-11-28 20:44:40 +01:00
|
|
|
CompactionIterationStats range_del_out_stats;
|
2020-09-17 00:45:30 +02:00
|
|
|
status = FinishCompactionOutputFile(input->status(), sub_compact,
|
|
|
|
&range_del_agg, &range_del_out_stats,
|
|
|
|
next_key);
|
2016-11-28 20:44:40 +01:00
|
|
|
RecordDroppedKeys(range_del_out_stats,
|
|
|
|
&sub_compact->compaction_job_stats);
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
}
|
2015-07-29 04:21:55 +02:00
|
|
|
|
2021-03-04 09:42:11 +01:00
|
|
|
sub_compact->compaction_job_stats.num_blobs_read =
|
|
|
|
c_iter_stats.num_blobs_read;
|
|
|
|
sub_compact->compaction_job_stats.total_blob_bytes_read =
|
|
|
|
c_iter_stats.total_blob_bytes_read;
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->compaction_job_stats.num_input_deletion_records =
|
|
|
|
c_iter_stats.num_input_deletion_records;
|
|
|
|
sub_compact->compaction_job_stats.num_corrupt_keys =
|
|
|
|
c_iter_stats.num_input_corrupt_records;
|
2016-08-16 17:21:43 +02:00
|
|
|
sub_compact->compaction_job_stats.num_single_del_fallthru =
|
|
|
|
c_iter_stats.num_single_del_fallthru;
|
|
|
|
sub_compact->compaction_job_stats.num_single_del_mismatch =
|
|
|
|
c_iter_stats.num_single_del_mismatch;
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->compaction_job_stats.total_input_raw_key_bytes +=
|
|
|
|
c_iter_stats.total_input_raw_key_bytes;
|
|
|
|
sub_compact->compaction_job_stats.total_input_raw_value_bytes +=
|
|
|
|
c_iter_stats.total_input_raw_value_bytes;
|
|
|
|
|
|
|
|
RecordTick(stats_, FILTER_OPERATION_TOTAL_TIME,
|
|
|
|
c_iter_stats.total_filter_time);
|
|
|
|
RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
|
2014-11-01 00:31:25 +01:00
|
|
|
RecordCompactionIOStats();
|
|
|
|
|
2019-05-20 19:37:37 +02:00
|
|
|
if (status.ok() && cfd->IsDropped()) {
|
|
|
|
status =
|
|
|
|
Status::ColumnFamilyDropped("Column family dropped during compaction");
|
|
|
|
}
|
|
|
|
if ((status.ok() || status.IsColumnFamilyDropped()) &&
|
|
|
|
shutting_down_->load(std::memory_order_relaxed)) {
|
|
|
|
status = Status::ShutdownInProgress("Database shutdown");
|
2015-07-29 04:21:55 +02:00
|
|
|
}
|
2019-09-17 06:00:13 +02:00
|
|
|
if ((status.ok() || status.IsColumnFamilyDropped()) &&
|
2021-06-07 20:40:31 +02:00
|
|
|
((manual_compaction_paused_ &&
|
|
|
|
manual_compaction_paused_->load(std::memory_order_relaxed) > 0) ||
|
|
|
|
(manual_compaction_canceled_ &&
|
|
|
|
manual_compaction_canceled_->load(std::memory_order_relaxed)))) {
|
2019-09-17 06:00:13 +02:00
|
|
|
status = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
|
|
|
|
}
|
2017-01-12 00:01:21 +01:00
|
|
|
if (status.ok()) {
|
|
|
|
status = input->status();
|
|
|
|
}
|
|
|
|
if (status.ok()) {
|
|
|
|
status = c_iter->status();
|
|
|
|
}
|
|
|
|
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
if (status.ok() && sub_compact->builder == nullptr &&
|
2018-12-17 22:12:22 +01:00
|
|
|
sub_compact->outputs.size() == 0 && !range_del_agg.IsEmpty()) {
|
2016-11-15 02:35:46 +01:00
|
|
|
// handle subcompaction containing only range deletions
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
status = OpenCompactionOutputFile(sub_compact);
|
|
|
|
}
|
2017-01-12 00:01:21 +01:00
|
|
|
|
|
|
|
// Call FinishCompactionOutputFile() even if status is not ok: it needs to
|
|
|
|
// close the output file.
|
|
|
|
if (sub_compact->builder != nullptr) {
|
2016-11-28 20:44:40 +01:00
|
|
|
CompactionIterationStats range_del_out_stats;
|
2018-12-17 22:12:22 +01:00
|
|
|
Status s = FinishCompactionOutputFile(status, sub_compact, &range_del_agg,
|
2018-11-21 19:53:44 +01:00
|
|
|
&range_del_out_stats);
|
2020-09-17 00:45:30 +02:00
|
|
|
if (!s.ok() && status.ok()) {
|
2017-01-12 00:01:21 +01:00
|
|
|
status = s;
|
|
|
|
}
|
2016-11-28 20:44:40 +01:00
|
|
|
RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
|
2015-07-29 04:21:55 +02:00
|
|
|
}
|
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
if (blob_file_builder) {
|
|
|
|
if (status.ok()) {
|
|
|
|
status = blob_file_builder->Finish();
|
2021-03-18 04:43:22 +01:00
|
|
|
} else {
|
|
|
|
blob_file_builder->Abandon();
|
2020-10-26 21:50:03 +01:00
|
|
|
}
|
|
|
|
blob_file_builder.reset();
|
|
|
|
}
|
|
|
|
|
2019-01-30 01:23:21 +01:00
|
|
|
sub_compact->compaction_job_stats.cpu_micros =
|
2021-03-15 12:32:24 +01:00
|
|
|
db_options_.clock->CPUNanos() / 1000 - prev_cpu_micros;
|
2019-01-30 01:23:21 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
if (measure_io_stats_) {
|
|
|
|
sub_compact->compaction_job_stats.file_write_nanos +=
|
2015-10-19 22:40:44 +02:00
|
|
|
IOSTATS(write_nanos) - prev_write_nanos;
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->compaction_job_stats.file_fsync_nanos +=
|
2015-10-19 22:40:44 +02:00
|
|
|
IOSTATS(fsync_nanos) - prev_fsync_nanos;
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->compaction_job_stats.file_range_sync_nanos +=
|
2015-10-19 22:40:44 +02:00
|
|
|
IOSTATS(range_sync_nanos) - prev_range_sync_nanos;
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->compaction_job_stats.file_prepare_write_nanos +=
|
2015-10-19 22:40:44 +02:00
|
|
|
IOSTATS(prepare_write_nanos) - prev_prepare_write_nanos;
|
2019-01-30 01:23:21 +01:00
|
|
|
sub_compact->compaction_job_stats.cpu_micros -=
|
2019-01-31 20:53:29 +01:00
|
|
|
(IOSTATS(cpu_write_nanos) - prev_cpu_write_nanos +
|
|
|
|
IOSTATS(cpu_read_nanos) - prev_cpu_read_nanos) /
|
|
|
|
1000;
|
2019-01-30 01:23:21 +01:00
|
|
|
if (prev_perf_level != PerfLevel::kEnableTimeAndCPUTimeExceptForMutex) {
|
2015-08-18 20:06:23 +02:00
|
|
|
SetPerfLevel(prev_perf_level);
|
|
|
|
}
|
|
|
|
}
|
2020-09-29 18:47:33 +02:00
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
if (!status.ok()) {
|
|
|
|
if (sub_compact->c_iter) {
|
|
|
|
sub_compact->c_iter->status().PermitUncheckedError();
|
|
|
|
}
|
|
|
|
if (input) {
|
|
|
|
input->status().PermitUncheckedError();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->c_iter.reset();
|
2021-06-10 00:40:16 +02:00
|
|
|
clip.reset();
|
|
|
|
raw_input.reset();
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->status = status;
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
|
2015-06-03 02:07:16 +02:00
|
|
|
void CompactionJob::RecordDroppedKeys(
|
2016-11-28 20:44:40 +01:00
|
|
|
const CompactionIterationStats& c_iter_stats,
|
2015-08-18 20:06:23 +02:00
|
|
|
CompactionJobStats* compaction_job_stats) {
|
2015-09-10 23:35:25 +02:00
|
|
|
if (c_iter_stats.num_record_drop_user > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_KEY_DROP_USER,
|
|
|
|
c_iter_stats.num_record_drop_user);
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
if (c_iter_stats.num_record_drop_hidden > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_KEY_DROP_NEWER_ENTRY,
|
|
|
|
c_iter_stats.num_record_drop_hidden);
|
2015-08-18 20:06:23 +02:00
|
|
|
if (compaction_job_stats) {
|
2015-09-10 23:35:25 +02:00
|
|
|
compaction_job_stats->num_records_replaced +=
|
|
|
|
c_iter_stats.num_record_drop_hidden;
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
if (c_iter_stats.num_record_drop_obsolete > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_KEY_DROP_OBSOLETE,
|
|
|
|
c_iter_stats.num_record_drop_obsolete);
|
2015-08-18 20:06:23 +02:00
|
|
|
if (compaction_job_stats) {
|
2015-09-10 23:35:25 +02:00
|
|
|
compaction_job_stats->num_expired_deletion_records +=
|
|
|
|
c_iter_stats.num_record_drop_obsolete;
|
2015-07-14 00:51:38 +02:00
|
|
|
}
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
2016-11-28 20:44:40 +01:00
|
|
|
if (c_iter_stats.num_record_drop_range_del > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_KEY_DROP_RANGE_DEL,
|
|
|
|
c_iter_stats.num_record_drop_range_del);
|
|
|
|
}
|
|
|
|
if (c_iter_stats.num_range_del_drop_obsolete > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_RANGE_DEL_DROP_OBSOLETE,
|
|
|
|
c_iter_stats.num_range_del_drop_obsolete);
|
|
|
|
}
|
2017-08-19 23:01:25 +02:00
|
|
|
if (c_iter_stats.num_optimized_del_drop_obsolete > 0) {
|
|
|
|
RecordTick(stats_, COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE,
|
|
|
|
c_iter_stats.num_optimized_del_drop_obsolete);
|
|
|
|
}
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
Status CompactionJob::FinishCompactionOutputFile(
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
const Status& input_status, SubcompactionState* sub_compact,
|
2018-12-18 02:26:56 +01:00
|
|
|
CompactionRangeDelAggregator* range_del_agg,
|
2016-11-28 20:44:40 +01:00
|
|
|
CompactionIterationStats* range_del_out_stats,
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
const Slice* next_table_min_key /* = nullptr */) {
|
2015-03-13 18:45:40 +01:00
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_SYNC_FILE);
|
2015-08-18 20:06:23 +02:00
|
|
|
assert(sub_compact != nullptr);
|
|
|
|
assert(sub_compact->outfile);
|
|
|
|
assert(sub_compact->builder != nullptr);
|
2015-08-18 21:27:12 +02:00
|
|
|
assert(sub_compact->current_output() != nullptr);
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
uint64_t output_number = sub_compact->current_output()->meta.fd.GetNumber();
|
2014-11-01 00:31:25 +01:00
|
|
|
assert(output_number != 0);
|
|
|
|
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
|
|
|
|
const Comparator* ucmp = cfd->user_comparator();
|
2020-08-25 19:44:39 +02:00
|
|
|
std::string file_checksum = kUnknownFileChecksum;
|
|
|
|
std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
// Check for iterator errors
|
2015-07-15 18:55:45 +02:00
|
|
|
Status s = input_status;
|
2015-09-10 23:35:25 +02:00
|
|
|
auto meta = &sub_compact->current_output()->meta;
|
2018-06-29 03:59:18 +02:00
|
|
|
assert(meta != nullptr);
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
if (s.ok()) {
|
2016-11-15 05:20:14 +01:00
|
|
|
Slice lower_bound_guard, upper_bound_guard;
|
2017-10-17 20:09:29 +02:00
|
|
|
std::string smallest_user_key;
|
2016-11-15 05:20:14 +01:00
|
|
|
const Slice *lower_bound, *upper_bound;
|
Properly set smallest key of subcompaction output (#4723)
Summary:
It is possible to see a situation like the following when
subcompactions are enabled:
1. A subcompaction boundary is set to `[b, e)`.
2. The first output file in a subcompaction has `c@20` as its smallest key
3. The range tombstone `[a, d)30` is encountered.
4. The tombstone is written to the range-del meta block and the new
smallest key is set to `b@0` (since no keys in this subcompaction's
output can be smaller than `b`).
5. A key `b@10` in a lower level will now reappear, since it is not
covered by the truncated start key `b@0`.
In general, unless the smallest data key in a file has a seqnum of 0, it
is not safe to truncate a tombstone at the start key to have a seqnum of
0, since it can expose keys with a seqnum greater than 0 but less than
the tombstone's actual seqnum.
To fix this, when the lower bound of a file is from the subcompaction
boundaries, we now set the seqnum of an artificially extended smallest
key to the tombstone's seqnum. This is safe because subcompactions
operate over disjoint sets of keys, and the subcompactions that can
experience this problem are not the first subcompaction (which is
unbounded on the left).
Furthermore, there is now an assertion to detect the described anomalous
case.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4723
Differential Revision: D13236188
Pulled By: abhimadan
fbshipit-source-id: a6da6a113f2de1e2ff307ca72e055300c8fe5692
2018-12-10 21:33:03 +01:00
|
|
|
bool lower_bound_from_sub_compact = false;
|
2016-11-15 05:20:14 +01:00
|
|
|
if (sub_compact->outputs.size() == 1) {
|
|
|
|
// For the first output table, include range tombstones before the min key
|
|
|
|
// but after the subcompaction boundary.
|
|
|
|
lower_bound = sub_compact->start;
|
Properly set smallest key of subcompaction output (#4723)
Summary:
It is possible to see a situation like the following when
subcompactions are enabled:
1. A subcompaction boundary is set to `[b, e)`.
2. The first output file in a subcompaction has `c@20` as its smallest key
3. The range tombstone `[a, d)30` is encountered.
4. The tombstone is written to the range-del meta block and the new
smallest key is set to `b@0` (since no keys in this subcompaction's
output can be smaller than `b`).
5. A key `b@10` in a lower level will now reappear, since it is not
covered by the truncated start key `b@0`.
In general, unless the smallest data key in a file has a seqnum of 0, it
is not safe to truncate a tombstone at the start key to have a seqnum of
0, since it can expose keys with a seqnum greater than 0 but less than
the tombstone's actual seqnum.
To fix this, when the lower bound of a file is from the subcompaction
boundaries, we now set the seqnum of an artificially extended smallest
key to the tombstone's seqnum. This is safe because subcompactions
operate over disjoint sets of keys, and the subcompactions that can
experience this problem are not the first subcompaction (which is
unbounded on the left).
Furthermore, there is now an assertion to detect the described anomalous
case.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4723
Differential Revision: D13236188
Pulled By: abhimadan
fbshipit-source-id: a6da6a113f2de1e2ff307ca72e055300c8fe5692
2018-12-10 21:33:03 +01:00
|
|
|
lower_bound_from_sub_compact = true;
|
2016-11-15 05:20:14 +01:00
|
|
|
} else if (meta->smallest.size() > 0) {
|
|
|
|
// For subsequent output tables, only include range tombstones from min
|
|
|
|
// key onwards since the previous file was extended to contain range
|
|
|
|
// tombstones falling before min key.
|
2017-10-17 20:09:29 +02:00
|
|
|
smallest_user_key = meta->smallest.user_key().ToString(false /*hex*/);
|
|
|
|
lower_bound_guard = Slice(smallest_user_key);
|
2016-11-15 05:20:14 +01:00
|
|
|
lower_bound = &lower_bound_guard;
|
|
|
|
} else {
|
|
|
|
lower_bound = nullptr;
|
|
|
|
}
|
|
|
|
if (next_table_min_key != nullptr) {
|
2019-02-05 19:15:33 +01:00
|
|
|
// This may be the last file in the subcompaction in some cases, so we
|
|
|
|
// need to compare the end key of subcompaction with the next file start
|
|
|
|
// key. When the end key is chosen by the subcompaction, we know that
|
|
|
|
// it must be the biggest key in output file. Therefore, it is safe to
|
|
|
|
// use the smaller key as the upper bound of the output file, to ensure
|
|
|
|
// that there is no overlapping between different output files.
|
2016-11-15 05:20:14 +01:00
|
|
|
upper_bound_guard = ExtractUserKey(*next_table_min_key);
|
2019-02-05 19:15:33 +01:00
|
|
|
if (sub_compact->end != nullptr &&
|
|
|
|
ucmp->Compare(upper_bound_guard, *sub_compact->end) >= 0) {
|
|
|
|
upper_bound = sub_compact->end;
|
|
|
|
} else {
|
|
|
|
upper_bound = &upper_bound_guard;
|
|
|
|
}
|
2016-11-15 05:20:14 +01:00
|
|
|
} else {
|
|
|
|
// This is the last file in the subcompaction, so extend until the
|
|
|
|
// subcompaction ends.
|
|
|
|
upper_bound = sub_compact->end;
|
|
|
|
}
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
auto earliest_snapshot = kMaxSequenceNumber;
|
|
|
|
if (existing_snapshots_.size() > 0) {
|
|
|
|
earliest_snapshot = existing_snapshots_[0];
|
|
|
|
}
|
2018-10-30 03:21:24 +01:00
|
|
|
bool has_overlapping_endpoints;
|
|
|
|
if (upper_bound != nullptr && meta->largest.size() > 0) {
|
|
|
|
has_overlapping_endpoints =
|
|
|
|
ucmp->Compare(meta->largest.user_key(), *upper_bound) == 0;
|
|
|
|
} else {
|
|
|
|
has_overlapping_endpoints = false;
|
|
|
|
}
|
2018-12-17 22:12:22 +01:00
|
|
|
|
2019-02-05 19:15:33 +01:00
|
|
|
// The end key of the subcompaction must be bigger or equal to the upper
|
|
|
|
// bound. If the end of subcompaction is null or the upper bound is null,
|
|
|
|
// it means that this file is the last file in the compaction. So there
|
|
|
|
// will be no overlapping between this file and others.
|
|
|
|
assert(sub_compact->end == nullptr ||
|
|
|
|
upper_bound == nullptr ||
|
|
|
|
ucmp->Compare(*upper_bound , *sub_compact->end) <= 0);
|
2018-12-17 22:12:22 +01:00
|
|
|
auto it = range_del_agg->NewIterator(lower_bound, upper_bound,
|
|
|
|
has_overlapping_endpoints);
|
|
|
|
// Position the range tombstone output iterator. There may be tombstone
|
|
|
|
// fragments that are entirely out of range, so make sure that we do not
|
|
|
|
// include those.
|
|
|
|
if (lower_bound != nullptr) {
|
|
|
|
it->Seek(*lower_bound);
|
|
|
|
} else {
|
|
|
|
it->SeekToFirst();
|
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
TEST_SYNC_POINT("CompactionJob::FinishCompactionOutputFile1");
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
for (; it->Valid(); it->Next()) {
|
|
|
|
auto tombstone = it->Tombstone();
|
2018-10-30 03:21:24 +01:00
|
|
|
if (upper_bound != nullptr) {
|
|
|
|
int cmp = ucmp->Compare(*upper_bound, tombstone.start_key_);
|
|
|
|
if ((has_overlapping_endpoints && cmp < 0) ||
|
|
|
|
(!has_overlapping_endpoints && cmp <= 0)) {
|
|
|
|
// Tombstones starting after upper_bound only need to be included in
|
|
|
|
// the next table. If the current SST ends before upper_bound, i.e.,
|
|
|
|
// `has_overlapping_endpoints == false`, we can also skip over range
|
|
|
|
// tombstones that start exactly at upper_bound. Such range tombstones
|
|
|
|
// will be included in the next file and are not relevant to the point
|
|
|
|
// keys or endpoints of the current file.
|
|
|
|
break;
|
|
|
|
}
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bottommost_level_ && tombstone.seq_ <= earliest_snapshot) {
|
|
|
|
// TODO(andrewkr): tombstones that span multiple output files are
|
|
|
|
// counted for each compaction output file, so lots of double counting.
|
|
|
|
range_del_out_stats->num_range_del_drop_obsolete++;
|
|
|
|
range_del_out_stats->num_record_drop_obsolete++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto kv = tombstone.Serialize();
|
2018-12-17 22:12:22 +01:00
|
|
|
assert(lower_bound == nullptr ||
|
|
|
|
ucmp->Compare(*lower_bound, kv.second) < 0);
|
2020-10-01 19:08:52 +02:00
|
|
|
// Range tombstone is not supported by output validator yet.
|
|
|
|
sub_compact->builder->Add(kv.first.Encode(), kv.second);
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
InternalKey smallest_candidate = std::move(kv.first);
|
|
|
|
if (lower_bound != nullptr &&
|
|
|
|
ucmp->Compare(smallest_candidate.user_key(), *lower_bound) <= 0) {
|
|
|
|
// Pretend the smallest key has the same user key as lower_bound
|
|
|
|
// (the max key in the previous table or subcompaction) in order for
|
|
|
|
// files to appear key-space partitioned.
|
|
|
|
//
|
Properly set smallest key of subcompaction output (#4723)
Summary:
It is possible to see a situation like the following when
subcompactions are enabled:
1. A subcompaction boundary is set to `[b, e)`.
2. The first output file in a subcompaction has `c@20` as its smallest key
3. The range tombstone `[a, d)30` is encountered.
4. The tombstone is written to the range-del meta block and the new
smallest key is set to `b@0` (since no keys in this subcompaction's
output can be smaller than `b`).
5. A key `b@10` in a lower level will now reappear, since it is not
covered by the truncated start key `b@0`.
In general, unless the smallest data key in a file has a seqnum of 0, it
is not safe to truncate a tombstone at the start key to have a seqnum of
0, since it can expose keys with a seqnum greater than 0 but less than
the tombstone's actual seqnum.
To fix this, when the lower bound of a file is from the subcompaction
boundaries, we now set the seqnum of an artificially extended smallest
key to the tombstone's seqnum. This is safe because subcompactions
operate over disjoint sets of keys, and the subcompactions that can
experience this problem are not the first subcompaction (which is
unbounded on the left).
Furthermore, there is now an assertion to detect the described anomalous
case.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4723
Differential Revision: D13236188
Pulled By: abhimadan
fbshipit-source-id: a6da6a113f2de1e2ff307ca72e055300c8fe5692
2018-12-10 21:33:03 +01:00
|
|
|
// When lower_bound is chosen by a subcompaction, we know that
|
|
|
|
// subcompactions over smaller keys cannot contain any keys at
|
|
|
|
// lower_bound. We also know that smaller subcompactions exist, because
|
|
|
|
// otherwise the subcompaction woud be unbounded on the left. As a
|
|
|
|
// result, we know that no other files on the output level will contain
|
|
|
|
// actual keys at lower_bound (an output file may have a largest key of
|
|
|
|
// lower_bound@kMaxSequenceNumber, but this only indicates a large range
|
|
|
|
// tombstone was truncated). Therefore, it is safe to use the
|
|
|
|
// tombstone's sequence number, to ensure that keys at lower_bound at
|
|
|
|
// lower levels are covered by truncated tombstones.
|
|
|
|
//
|
|
|
|
// If lower_bound was chosen by the smallest data key in the file,
|
|
|
|
// choose lowest seqnum so this file's smallest internal key comes after
|
|
|
|
// the previous file's largest. The fake seqnum is OK because the read
|
|
|
|
// path's file-picking code only considers user key.
|
|
|
|
smallest_candidate = InternalKey(
|
|
|
|
*lower_bound, lower_bound_from_sub_compact ? tombstone.seq_ : 0,
|
|
|
|
kTypeRangeDeletion);
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
}
|
|
|
|
InternalKey largest_candidate = tombstone.SerializeEndKey();
|
|
|
|
if (upper_bound != nullptr &&
|
|
|
|
ucmp->Compare(*upper_bound, largest_candidate.user_key()) <= 0) {
|
|
|
|
// Pretend the largest key has the same user key as upper_bound (the
|
|
|
|
// min key in the following table or subcompaction) in order for files
|
|
|
|
// to appear key-space partitioned.
|
|
|
|
//
|
|
|
|
// Choose highest seqnum so this file's largest internal key comes
|
|
|
|
// before the next file's/subcompaction's smallest. The fake seqnum is
|
|
|
|
// OK because the read path's file-picking code only considers the user
|
|
|
|
// key portion.
|
|
|
|
//
|
|
|
|
// Note Seek() also creates InternalKey with (user_key,
|
|
|
|
// kMaxSequenceNumber), but with kTypeDeletion (0x7) instead of
|
|
|
|
// kTypeRangeDeletion (0xF), so the range tombstone comes before the
|
|
|
|
// Seek() key in InternalKey's ordering. So Seek() will look in the
|
|
|
|
// next file for the user key.
|
|
|
|
largest_candidate =
|
|
|
|
InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion);
|
|
|
|
}
|
Properly set smallest key of subcompaction output (#4723)
Summary:
It is possible to see a situation like the following when
subcompactions are enabled:
1. A subcompaction boundary is set to `[b, e)`.
2. The first output file in a subcompaction has `c@20` as its smallest key
3. The range tombstone `[a, d)30` is encountered.
4. The tombstone is written to the range-del meta block and the new
smallest key is set to `b@0` (since no keys in this subcompaction's
output can be smaller than `b`).
5. A key `b@10` in a lower level will now reappear, since it is not
covered by the truncated start key `b@0`.
In general, unless the smallest data key in a file has a seqnum of 0, it
is not safe to truncate a tombstone at the start key to have a seqnum of
0, since it can expose keys with a seqnum greater than 0 but less than
the tombstone's actual seqnum.
To fix this, when the lower bound of a file is from the subcompaction
boundaries, we now set the seqnum of an artificially extended smallest
key to the tombstone's seqnum. This is safe because subcompactions
operate over disjoint sets of keys, and the subcompactions that can
experience this problem are not the first subcompaction (which is
unbounded on the left).
Furthermore, there is now an assertion to detect the described anomalous
case.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4723
Differential Revision: D13236188
Pulled By: abhimadan
fbshipit-source-id: a6da6a113f2de1e2ff307ca72e055300c8fe5692
2018-12-10 21:33:03 +01:00
|
|
|
#ifndef NDEBUG
|
|
|
|
SequenceNumber smallest_ikey_seqnum = kMaxSequenceNumber;
|
|
|
|
if (meta->smallest.size() > 0) {
|
|
|
|
smallest_ikey_seqnum = GetInternalKeySeqno(meta->smallest.Encode());
|
|
|
|
}
|
|
|
|
#endif
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
meta->UpdateBoundariesForRange(smallest_candidate, largest_candidate,
|
|
|
|
tombstone.seq_,
|
|
|
|
cfd->internal_comparator());
|
Properly set smallest key of subcompaction output (#4723)
Summary:
It is possible to see a situation like the following when
subcompactions are enabled:
1. A subcompaction boundary is set to `[b, e)`.
2. The first output file in a subcompaction has `c@20` as its smallest key
3. The range tombstone `[a, d)30` is encountered.
4. The tombstone is written to the range-del meta block and the new
smallest key is set to `b@0` (since no keys in this subcompaction's
output can be smaller than `b`).
5. A key `b@10` in a lower level will now reappear, since it is not
covered by the truncated start key `b@0`.
In general, unless the smallest data key in a file has a seqnum of 0, it
is not safe to truncate a tombstone at the start key to have a seqnum of
0, since it can expose keys with a seqnum greater than 0 but less than
the tombstone's actual seqnum.
To fix this, when the lower bound of a file is from the subcompaction
boundaries, we now set the seqnum of an artificially extended smallest
key to the tombstone's seqnum. This is safe because subcompactions
operate over disjoint sets of keys, and the subcompactions that can
experience this problem are not the first subcompaction (which is
unbounded on the left).
Furthermore, there is now an assertion to detect the described anomalous
case.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4723
Differential Revision: D13236188
Pulled By: abhimadan
fbshipit-source-id: a6da6a113f2de1e2ff307ca72e055300c8fe5692
2018-12-10 21:33:03 +01:00
|
|
|
|
|
|
|
// The smallest key in a file is used for range tombstone truncation, so
|
|
|
|
// it cannot have a seqnum of 0 (unless the smallest data key in a file
|
|
|
|
// has a seqnum of 0). Otherwise, the truncated tombstone may expose
|
|
|
|
// deleted keys at lower levels.
|
|
|
|
assert(smallest_ikey_seqnum == 0 ||
|
|
|
|
ExtractInternalKeyFooter(meta->smallest.Encode()) !=
|
|
|
|
PackSequenceAndType(0, kTypeRangeDeletion));
|
Range deletion performance improvements + cleanup (#4014)
Summary:
This fixes the same performance issue that #3992 fixes but with much more invasive cleanup.
I'm more excited about this PR because it paves the way for fixing another problem we uncovered at Cockroach where range deletion tombstones can cause massive compactions. For example, suppose L4 contains deletions from [a, c) and [x, z) and no other keys, and L5 is entirely empty. L6, however, is full of data. When compacting L4 -> L5, we'll end up with one file that spans, massively, from [a, z). When we go to compact L5 -> L6, we'll have to rewrite all of L6! If, instead of range deletions in L4, we had keys a, b, x, y, and z, RocksDB would have been smart enough to create two files in L5: one for a and b and another for x, y, and z.
With the changes in this PR, it will be possible to adjust the compaction logic to split tombstones/start new output files when they would span too many files in the grandparent level.
ajkr please take a look when you have a minute!
Pull Request resolved: https://github.com/facebook/rocksdb/pull/4014
Differential Revision: D8773253
Pulled By: ajkr
fbshipit-source-id: ec62fa85f648fdebe1380b83ed997f9baec35677
2018-07-12 23:28:10 +02:00
|
|
|
}
|
Compaction Support for Range Deletion
Summary:
This diff introduces RangeDelAggregator, which takes ownership of iterators
provided to it via AddTombstones(). The tombstones are organized in a two-level
map (snapshot stripe -> begin key -> tombstone). Tombstone creation avoids data
copy by holding Slices returned by the iterator, which remain valid thanks to pinning.
For compaction, we create a hierarchical range tombstone iterator with structure
matching the iterator over compaction input data. An aggregator based on that
iterator is used by CompactionIterator to determine which keys are covered by
range tombstones. In case of merge operand, the same aggregator is used by
MergeHelper. Upon finishing each file in the compaction, relevant range tombstones
are added to the output file's range tombstone metablock and file boundaries are
updated accordingly.
To check whether a key is covered by range tombstone, RangeDelAggregator::ShouldDelete()
considers tombstones in the key's snapshot stripe. When this function is used outside of
compaction, it also checks newer stripes, which can contain covering tombstones. Currently
the intra-stripe check involves a linear scan; however, in the future we plan to collapse ranges
within a stripe such that binary search can be used.
RangeDelAggregator::AddToBuilder() adds all range tombstones in the table's key-range
to a new table's range tombstone meta-block. Since range tombstones may fall in the gap
between files, we may need to extend some files' key-ranges. The strategy is (1) first file
extends as far left as possible and other files do not extend left, (2) all files extend right
until either the start of the next file or the end of the last range tombstone in the gap,
whichever comes first.
One other notable change is adding release/move semantics to ScopedArenaIterator
such that it can be used to transfer ownership of an arena-allocated iterator, similar to
how unique_ptr is used for malloc'd data.
Depends on D61473
Test Plan: compaction_iterator_test, mock_table, end-to-end tests in D63927
Reviewers: sdong, IslamAbdelRahman, wanning, yhchiang, lightmark
Reviewed By: lightmark
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D62205
2016-10-18 21:04:56 +02:00
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
const uint64_t current_entries = sub_compact->builder->NumEntries();
|
2014-11-01 00:31:25 +01:00
|
|
|
if (s.ok()) {
|
2015-08-18 20:06:23 +02:00
|
|
|
s = sub_compact->builder->Finish();
|
2014-11-01 00:31:25 +01:00
|
|
|
} else {
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->builder->Abandon();
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
2021-01-06 22:16:47 +01:00
|
|
|
IOStatus io_s = sub_compact->builder->io_status();
|
2020-07-15 20:02:44 +02:00
|
|
|
if (s.ok()) {
|
2021-01-06 22:16:47 +01:00
|
|
|
s = io_s;
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
const uint64_t current_bytes = sub_compact->builder->FileSize();
|
2017-09-07 23:11:15 +02:00
|
|
|
if (s.ok()) {
|
|
|
|
meta->fd.file_size = current_bytes;
|
2020-11-04 19:43:17 +01:00
|
|
|
meta->marked_for_compaction = sub_compact->builder->NeedCompact();
|
2017-09-07 23:11:15 +02:00
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
sub_compact->current_output()->finished = true;
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->total_bytes += current_bytes;
|
2014-11-01 00:31:25 +01:00
|
|
|
|
|
|
|
// Finish and check for file errors
|
2017-02-13 19:54:38 +01:00
|
|
|
if (s.ok()) {
|
2021-03-15 12:32:24 +01:00
|
|
|
StopWatch sw(db_options_.clock, stats_, COMPACTION_OUTFILE_SYNC_MICROS);
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
io_s = sub_compact->outfile->Sync(db_options_.use_fsync);
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
if (s.ok() && io_s.ok()) {
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
io_s = sub_compact->outfile->Close();
|
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
if (s.ok() && io_s.ok()) {
|
2020-03-30 00:57:02 +02:00
|
|
|
// Add the checksum information to file metadata.
|
|
|
|
meta->file_checksum = sub_compact->outfile->GetFileChecksum();
|
|
|
|
meta->file_checksum_func_name =
|
|
|
|
sub_compact->outfile->GetFileChecksumFuncName();
|
2020-08-25 19:44:39 +02:00
|
|
|
file_checksum = meta->file_checksum;
|
|
|
|
file_checksum_func_name = meta->file_checksum_func_name;
|
2020-03-30 00:57:02 +02:00
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
if (s.ok()) {
|
Pass IOStatus to write path and set retryable IO Error as hard error in BG jobs (#6487)
Summary:
In the current code base, we use Status to get and store the returned status from the call. Specifically, for IO related functions, the current Status cannot reflect the IO Error details such as error scope, error retryable attribute, and others. With the implementation of https://github.com/facebook/rocksdb/issues/5761, we have the new Wrapper for IO, which returns IOStatus instead of Status. However, the IOStatus is purged at the lower level of write path and transferred to Status.
The first job of this PR is to pass the IOStatus to the write path (flush, WAL write, and Compaction). The second job is to identify the Retryable IO Error as HardError, and set the bg_error_ as HardError. In this case, the DB Instance becomes read only. User is informed of the Status and need to take actions to deal with it (e.g., call db->Resume()).
Pull Request resolved: https://github.com/facebook/rocksdb/pull/6487
Test Plan: Added the testing case to error_handler_fs_test. Pass make asan_check
Reviewed By: anand1976
Differential Revision: D20685017
Pulled By: zhichao-cao
fbshipit-source-id: ff85f042896243abcd6ef37877834e26f36b6eb0
2020-03-28 00:03:05 +01:00
|
|
|
s = io_s;
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
2020-07-15 20:02:44 +02:00
|
|
|
if (sub_compact->io_status.ok()) {
|
|
|
|
sub_compact->io_status = io_s;
|
2020-09-17 00:45:30 +02:00
|
|
|
// Since this error is really a copy of the
|
|
|
|
// "normal" status, it does not also need to be checked
|
|
|
|
sub_compact->io_status.PermitUncheckedError();
|
2020-07-15 20:02:44 +02:00
|
|
|
}
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->outfile.reset();
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2018-06-27 05:18:43 +02:00
|
|
|
TableProperties tp;
|
|
|
|
if (s.ok()) {
|
|
|
|
tp = sub_compact->builder->GetTableProperties();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s.ok() && current_entries == 0 && tp.num_range_deletions == 0) {
|
2017-06-30 00:13:02 +02:00
|
|
|
// If there is nothing to output, no necessary to generate a sst file.
|
|
|
|
// This happens when the output level is bottom level, at the same time
|
|
|
|
// the sub_compact output nothing.
|
2018-04-13 02:55:14 +02:00
|
|
|
std::string fname =
|
|
|
|
TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
|
|
|
|
meta->fd.GetNumber(), meta->fd.GetPathId());
|
2020-12-23 00:08:17 +01:00
|
|
|
|
|
|
|
// TODO(AR) it is not clear if there are any larger implications if
|
|
|
|
// DeleteFile fails here
|
|
|
|
Status ds = env_->DeleteFile(fname);
|
|
|
|
if (!ds.ok()) {
|
|
|
|
ROCKS_LOG_WARN(
|
|
|
|
db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Unable to remove SST file for table #%" PRIu64
|
|
|
|
" at bottom level%s",
|
|
|
|
cfd->GetName().c_str(), job_id_, output_number,
|
|
|
|
meta->marked_for_compaction ? " (need compaction)" : "");
|
|
|
|
}
|
2017-06-30 00:13:02 +02:00
|
|
|
|
|
|
|
// Also need to remove the file from outputs, or it will be added to the
|
|
|
|
// VersionEdit.
|
|
|
|
assert(!sub_compact->outputs.empty());
|
|
|
|
sub_compact->outputs.pop_back();
|
2018-08-24 03:22:55 +02:00
|
|
|
meta = nullptr;
|
2017-06-30 00:13:02 +02:00
|
|
|
}
|
|
|
|
|
2018-06-27 05:18:43 +02:00
|
|
|
if (s.ok() && (current_entries > 0 || tp.num_range_deletions > 0)) {
|
Added EventListener::OnTableFileCreationStarted() callback
Summary: Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
Test Plan: unit test.
Reviewers: dhruba, yhchiang, ott, sdong
Reviewed By: sdong
Subscribers: sdong, kradhakrishnan, IslamAbdelRahman, andrewkr, yhchiang, leveldb, ott, dhruba
Differential Revision: https://reviews.facebook.net/D56337
2016-04-29 20:35:00 +02:00
|
|
|
// Output to event logger and fire events.
|
2018-06-15 21:28:06 +02:00
|
|
|
sub_compact->current_output()->table_properties =
|
|
|
|
std::make_shared<TableProperties>(tp);
|
|
|
|
ROCKS_LOG_INFO(db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Generated table #%" PRIu64 ": %" PRIu64
|
|
|
|
" keys, %" PRIu64 " bytes%s",
|
|
|
|
cfd->GetName().c_str(), job_id_, output_number,
|
|
|
|
current_entries, current_bytes,
|
|
|
|
meta->marked_for_compaction ? " (need compaction)" : "");
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
2017-09-07 23:11:15 +02:00
|
|
|
std::string fname;
|
|
|
|
FileDescriptor output_fd;
|
2019-10-15 00:19:31 +02:00
|
|
|
uint64_t oldest_blob_file_number = kInvalidBlobFileNumber;
|
2017-09-07 23:11:15 +02:00
|
|
|
if (meta != nullptr) {
|
2021-04-22 22:01:00 +02:00
|
|
|
fname = GetTableFileName(meta->fd.GetNumber());
|
2017-09-07 23:11:15 +02:00
|
|
|
output_fd = meta->fd;
|
2019-10-15 00:19:31 +02:00
|
|
|
oldest_blob_file_number = meta->oldest_blob_file_number;
|
2017-09-07 23:11:15 +02:00
|
|
|
} else {
|
|
|
|
fname = "(nil)";
|
|
|
|
}
|
Added EventListener::OnTableFileCreationStarted() callback
Summary: Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
Test Plan: unit test.
Reviewers: dhruba, yhchiang, ott, sdong
Reviewed By: sdong
Subscribers: sdong, kradhakrishnan, IslamAbdelRahman, andrewkr, yhchiang, leveldb, ott, dhruba
Differential Revision: https://reviews.facebook.net/D56337
2016-04-29 20:35:00 +02:00
|
|
|
EventHelpers::LogAndNotifyTableFileCreationFinished(
|
|
|
|
event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname,
|
2019-10-15 00:19:31 +02:00
|
|
|
job_id_, output_fd, oldest_blob_file_number, tp,
|
2020-08-25 19:44:39 +02:00
|
|
|
TableFileCreationReason::kCompaction, s, file_checksum,
|
|
|
|
file_checksum_func_name);
|
2016-02-18 00:20:23 +01:00
|
|
|
|
2016-12-22 02:35:00 +01:00
|
|
|
#ifndef ROCKSDB_LITE
|
2016-02-18 00:20:23 +01:00
|
|
|
// Report new file to SstFileManagerImpl
|
|
|
|
auto sfm =
|
|
|
|
static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
|
2017-09-07 23:11:15 +02:00
|
|
|
if (sfm && meta != nullptr && meta->fd.GetPathId() == 0) {
|
2020-09-17 00:45:30 +02:00
|
|
|
Status add_s = sfm->OnAddFile(fname);
|
|
|
|
if (!add_s.ok() && s.ok()) {
|
|
|
|
s = add_s;
|
|
|
|
}
|
2016-02-18 00:20:23 +01:00
|
|
|
if (sfm->IsMaxAllowedSpaceReached()) {
|
2017-06-23 04:30:39 +02:00
|
|
|
// TODO(ajkr): should we return OK() if max space was reached by the final
|
|
|
|
// compaction output file (similarly to how flush works when full)?
|
2018-06-28 21:23:57 +02:00
|
|
|
s = Status::SpaceLimit("Max allowed space was reached");
|
2017-06-23 04:30:39 +02:00
|
|
|
TEST_SYNC_POINT(
|
|
|
|
"CompactionJob::FinishCompactionOutputFile:"
|
|
|
|
"MaxAllowedSpaceReached");
|
2016-02-18 00:20:23 +01:00
|
|
|
InstrumentedMutexLock l(db_mutex_);
|
2020-12-08 05:09:55 +01:00
|
|
|
db_error_handler_->SetBGError(s, BackgroundErrorReason::kCompaction);
|
2016-02-18 00:20:23 +01:00
|
|
|
}
|
|
|
|
}
|
2016-12-22 02:35:00 +01:00
|
|
|
#endif
|
2016-02-18 00:20:23 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->builder.reset();
|
2016-06-17 01:02:52 +02:00
|
|
|
sub_compact->current_output_file_size = 0;
|
2014-11-01 00:31:25 +01:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2015-05-06 04:01:12 +02:00
|
|
|
Status CompactionJob::InstallCompactionResults(
|
2016-02-18 00:20:23 +01:00
|
|
|
const MutableCFOptions& mutable_cf_options) {
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(compact_);
|
|
|
|
|
2016-02-18 00:20:23 +01:00
|
|
|
db_mutex_->AssertHeld();
|
2014-11-01 00:31:25 +01:00
|
|
|
|
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
|
|
|
auto* compaction = compact_->compaction;
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(compaction);
|
|
|
|
|
2014-11-01 00:31:25 +01:00
|
|
|
// paranoia: verify that the files that we started with
|
|
|
|
// still exist in the current version and in the same original level.
|
|
|
|
// This ensures that a concurrent compaction did not erroneously
|
|
|
|
// pick the same files to compact_.
|
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
|
|
|
if (!versions_->VerifyCompactionFileConsistency(compaction)) {
|
|
|
|
Compaction::InputLevelSummaryBuffer inputs_summary;
|
|
|
|
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_ERROR(db_options_.info_log, "[%s] [JOB %d] Compaction %s aborted",
|
|
|
|
compaction->column_family_data()->GetName().c_str(),
|
|
|
|
job_id_, compaction->InputLevelSummary(&inputs_summary));
|
2014-11-01 00:31:25 +01:00
|
|
|
return Status::Corruption("Compaction input files inconsistent");
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
Compaction::InputLevelSummaryBuffer inputs_summary;
|
2020-10-26 21:50:03 +01:00
|
|
|
ROCKS_LOG_INFO(db_options_.info_log,
|
|
|
|
"[%s] [JOB %d] Compacted %s => %" PRIu64 " bytes",
|
|
|
|
compaction->column_family_data()->GetName().c_str(), job_id_,
|
|
|
|
compaction->InputLevelSummary(&inputs_summary),
|
|
|
|
compact_->total_bytes + compact_->total_blob_bytes);
|
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
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
VersionEdit* const edit = compaction->edit();
|
|
|
|
assert(edit);
|
|
|
|
|
2018-04-09 22:36:23 +02:00
|
|
|
// Add compaction inputs
|
2020-10-26 21:50:03 +01:00
|
|
|
compaction->AddInputDeletions(edit);
|
2015-08-18 20:06:23 +02:00
|
|
|
|
2015-09-10 23:35:25 +02:00
|
|
|
for (const auto& sub_compact : compact_->sub_compact_states) {
|
|
|
|
for (const auto& out : sub_compact.outputs) {
|
2020-10-26 21:50:03 +01:00
|
|
|
edit->AddFile(compaction->output_level(), out.meta);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto& blob : sub_compact.blob_file_additions) {
|
|
|
|
edit->AddBlobFile(blob);
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
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
|
|
|
}
|
2020-10-26 21:50:03 +01:00
|
|
|
|
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
|
|
|
return versions_->LogAndApply(compaction->column_family_data(),
|
2020-10-26 21:50:03 +01:00
|
|
|
mutable_cf_options, edit, db_mutex_,
|
|
|
|
db_directory_);
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CompactionJob::RecordCompactionIOStats() {
|
|
|
|
RecordTick(stats_, COMPACT_READ_BYTES, IOSTATS(bytes_read));
|
2020-07-29 22:38:07 +02:00
|
|
|
RecordTick(stats_, COMPACT_WRITE_BYTES, IOSTATS(bytes_written));
|
|
|
|
CompactionReason compaction_reason =
|
|
|
|
compact_->compaction->compaction_reason();
|
|
|
|
if (compaction_reason == CompactionReason::kFilesMarkedForCompaction) {
|
|
|
|
RecordTick(stats_, COMPACT_READ_BYTES_MARKED, IOSTATS(bytes_read));
|
|
|
|
RecordTick(stats_, COMPACT_WRITE_BYTES_MARKED, IOSTATS(bytes_written));
|
|
|
|
} else if (compaction_reason == CompactionReason::kPeriodicCompaction) {
|
|
|
|
RecordTick(stats_, COMPACT_READ_BYTES_PERIODIC, IOSTATS(bytes_read));
|
|
|
|
RecordTick(stats_, COMPACT_WRITE_BYTES_PERIODIC, IOSTATS(bytes_written));
|
|
|
|
} else if (compaction_reason == CompactionReason::kTtl) {
|
|
|
|
RecordTick(stats_, COMPACT_READ_BYTES_TTL, IOSTATS(bytes_read));
|
|
|
|
RecordTick(stats_, COMPACT_WRITE_BYTES_TTL, IOSTATS(bytes_written));
|
|
|
|
}
|
2015-05-07 07:50:35 +02:00
|
|
|
ThreadStatusUtil::IncreaseThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_BYTES_READ, IOSTATS(bytes_read));
|
2014-11-01 00:31:25 +01:00
|
|
|
IOSTATS_RESET(bytes_read);
|
2015-05-07 07:50:35 +02:00
|
|
|
ThreadStatusUtil::IncreaseThreadOperationProperty(
|
|
|
|
ThreadStatus::COMPACTION_BYTES_WRITTEN, IOSTATS(bytes_written));
|
2014-11-01 00:31:25 +01:00
|
|
|
IOSTATS_RESET(bytes_written);
|
|
|
|
}
|
|
|
|
|
2015-09-10 22:50:00 +02:00
|
|
|
Status CompactionJob::OpenCompactionOutputFile(
|
|
|
|
SubcompactionState* sub_compact) {
|
2015-08-18 20:06:23 +02:00
|
|
|
assert(sub_compact != nullptr);
|
|
|
|
assert(sub_compact->builder == nullptr);
|
2014-11-08 00:44:12 +01:00
|
|
|
// no need to lock because VersionSet::next_file_number_ is atomic
|
|
|
|
uint64_t file_number = versions_->NewFileNumber();
|
2021-04-22 22:01:00 +02:00
|
|
|
std::string fname = GetTableFileName(file_number);
|
Added EventListener::OnTableFileCreationStarted() callback
Summary: Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
Test Plan: unit test.
Reviewers: dhruba, yhchiang, ott, sdong
Reviewed By: sdong
Subscribers: sdong, kradhakrishnan, IslamAbdelRahman, andrewkr, yhchiang, leveldb, ott, dhruba
Differential Revision: https://reviews.facebook.net/D56337
2016-04-29 20:35:00 +02:00
|
|
|
// Fire events.
|
|
|
|
ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
|
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
EventHelpers::NotifyTableFileCreationStarted(
|
|
|
|
cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname, job_id_,
|
|
|
|
TableFileCreationReason::kCompaction);
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
// Make the output file
|
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
|
|
|
std::unique_ptr<FSWritableFile> writable_file;
|
2017-10-03 00:11:40 +02:00
|
|
|
#ifndef NDEBUG
|
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
|
|
|
bool syncpoint_arg = file_options_.use_direct_writes;
|
2017-04-13 22:07:33 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK("CompactionJob::OpenCompactionOutputFile",
|
2017-09-28 02:37:08 +02:00
|
|
|
&syncpoint_arg);
|
2017-10-03 00:11:40 +02:00
|
|
|
#endif
|
2021-05-03 22:30:00 +02:00
|
|
|
|
|
|
|
// Pass temperature of botommost files to FileSystem.
|
|
|
|
FileOptions fo_copy = file_options_;
|
2021-05-18 00:14:34 +02:00
|
|
|
Temperature temperature = Temperature::kUnknown;
|
2021-05-03 22:30:00 +02:00
|
|
|
if (bottommost_level_) {
|
2021-05-18 00:14:34 +02:00
|
|
|
fo_copy.temperature = temperature =
|
2021-05-03 22:30:00 +02:00
|
|
|
sub_compact->compaction->mutable_cf_options()->bottommost_temperature;
|
|
|
|
}
|
|
|
|
|
2020-07-15 20:02:44 +02:00
|
|
|
Status s;
|
2021-05-03 22:30:00 +02:00
|
|
|
IOStatus io_s = NewWritableFile(fs_.get(), fname, &writable_file, fo_copy);
|
2020-07-15 20:02:44 +02:00
|
|
|
s = io_s;
|
|
|
|
if (sub_compact->io_status.ok()) {
|
|
|
|
sub_compact->io_status = io_s;
|
2020-09-25 06:47:43 +02:00
|
|
|
// Since this error is really a copy of the io_s that is checked below as s,
|
|
|
|
// it does not also need to be checked.
|
|
|
|
sub_compact->io_status.PermitUncheckedError();
|
2020-07-15 20:02:44 +02:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
if (!s.ok()) {
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_ERROR(
|
|
|
|
db_options_.info_log,
|
2015-02-12 18:54:48 +01:00
|
|
|
"[%s] [JOB %d] OpenCompactionOutputFiles for table #%" PRIu64
|
2014-11-04 20:07:11 +01:00
|
|
|
" fails at NewWritableFile with status %s",
|
2015-08-18 20:06:23 +02:00
|
|
|
sub_compact->compaction->column_family_data()->GetName().c_str(),
|
|
|
|
job_id_, file_number, s.ToString().c_str());
|
2014-11-01 00:31:25 +01:00
|
|
|
LogFlush(db_options_.info_log);
|
Added EventListener::OnTableFileCreationStarted() callback
Summary: Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
Test Plan: unit test.
Reviewers: dhruba, yhchiang, ott, sdong
Reviewed By: sdong
Subscribers: sdong, kradhakrishnan, IslamAbdelRahman, andrewkr, yhchiang, leveldb, ott, dhruba
Differential Revision: https://reviews.facebook.net/D56337
2016-04-29 20:35:00 +02:00
|
|
|
EventHelpers::LogAndNotifyTableFileCreationFinished(
|
|
|
|
event_logger_, cfd->ioptions()->listeners, dbname_, cfd->GetName(),
|
2019-10-15 00:19:31 +02:00
|
|
|
fname, job_id_, FileDescriptor(), kInvalidBlobFileNumber,
|
2020-08-25 19:44:39 +02:00
|
|
|
TableProperties(), TableFileCreationReason::kCompaction, s,
|
|
|
|
kUnknownFileChecksum, kUnknownFileChecksumFuncName);
|
2014-11-01 00:31:25 +01:00
|
|
|
return s;
|
|
|
|
}
|
Added EventListener::OnTableFileCreationStarted() callback
Summary: Added EventListener::OnTableFileCreationStarted. EventListener::OnTableFileCreated will be called on failure case. User can check creation status via TableFileCreationInfo::status.
Test Plan: unit test.
Reviewers: dhruba, yhchiang, ott, sdong
Reviewed By: sdong
Subscribers: sdong, kradhakrishnan, IslamAbdelRahman, andrewkr, yhchiang, leveldb, ott, dhruba
Differential Revision: https://reviews.facebook.net/D56337
2016-04-29 20:35:00 +02:00
|
|
|
|
2019-11-23 01:01:21 +01:00
|
|
|
// Try to figure out the output file's oldest ancester time.
|
|
|
|
int64_t temp_current_time = 0;
|
2021-03-15 12:32:24 +01:00
|
|
|
auto get_time_status = db_options_.clock->GetCurrentTime(&temp_current_time);
|
2019-11-23 01:01:21 +01:00
|
|
|
// Safe to proceed even if GetCurrentTime fails. So, log and proceed.
|
|
|
|
if (!get_time_status.ok()) {
|
|
|
|
ROCKS_LOG_WARN(db_options_.info_log,
|
|
|
|
"Failed to get current time. Status: %s",
|
|
|
|
get_time_status.ToString().c_str());
|
|
|
|
}
|
|
|
|
uint64_t current_time = static_cast<uint64_t>(temp_current_time);
|
|
|
|
uint64_t oldest_ancester_time =
|
|
|
|
sub_compact->compaction->MinInputFileOldestAncesterTime();
|
|
|
|
if (oldest_ancester_time == port::kMaxUint64) {
|
|
|
|
oldest_ancester_time = current_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize a SubcompactionState::Output and add it to sub_compact->outputs
|
|
|
|
{
|
2020-10-01 19:08:52 +02:00
|
|
|
FileMetaData meta;
|
|
|
|
meta.fd = FileDescriptor(file_number,
|
|
|
|
sub_compact->compaction->output_path_id(), 0);
|
|
|
|
meta.oldest_ancester_time = oldest_ancester_time;
|
|
|
|
meta.file_creation_time = current_time;
|
2021-05-18 00:14:34 +02:00
|
|
|
meta.temperature = temperature;
|
2020-10-01 19:08:52 +02:00
|
|
|
sub_compact->outputs.emplace_back(
|
|
|
|
std::move(meta), cfd->internal_comparator(),
|
|
|
|
/*enable_order_check=*/
|
|
|
|
sub_compact->compaction->mutable_cf_options()
|
|
|
|
->check_flush_compaction_key_order,
|
|
|
|
/*enable_hash=*/paranoid_file_checks_);
|
2019-11-23 01:01:21 +01:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
|
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
|
|
|
writable_file->SetIOPriority(Env::IOPriority::IO_LOW);
|
2017-11-10 18:25:26 +01:00
|
|
|
writable_file->SetWriteLifeTimeHint(write_hint_);
|
2021-02-11 07:18:33 +01:00
|
|
|
FileTypeSet tmp_set = db_options_.checksum_handoff_file_types;
|
2015-08-18 20:06:23 +02:00
|
|
|
writable_file->SetPreallocationBlockSize(static_cast<size_t>(
|
|
|
|
sub_compact->compaction->OutputFilePreallocationSize()));
|
2018-10-13 03:34:03 +02:00
|
|
|
const auto& listeners =
|
|
|
|
sub_compact->compaction->immutable_cf_options()->listeners;
|
2020-09-08 19:49:01 +02:00
|
|
|
sub_compact->outfile.reset(new WritableFileWriter(
|
2021-03-15 12:32:24 +01:00
|
|
|
std::move(writable_file), fname, file_options_, db_options_.clock,
|
2021-05-05 22:59:21 +02:00
|
|
|
io_tracer_, db_options_.stats, listeners,
|
2021-02-11 07:18:33 +01:00
|
|
|
db_options_.file_checksum_gen_factory.get(),
|
|
|
|
tmp_set.Contains(FileType::kTableFile)));
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2021-04-29 15:59:53 +02:00
|
|
|
TableBuilderOptions tboptions(
|
2018-05-21 23:33:55 +02:00
|
|
|
*cfd->ioptions(), *(sub_compact->compaction->mutable_cf_options()),
|
|
|
|
cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
|
|
|
|
sub_compact->compaction->output_compression(),
|
Add more LSM info to FilterBuildingContext (#8246)
Summary:
Add `num_levels`, `is_bottommost`, and table file creation
`reason` to `FilterBuildingContext`, in anticipation of more powerful
Bloom-like filter support.
To support this, added `is_bottommost` and `reason` to
`TableBuilderOptions`, which allowed removing `reason` parameter from
`rocksdb::BuildTable`.
I attempted to remove `skip_filters` from `TableBuilderOptions`, because
filter construction decisions should arise from options, not one-off
parameters. I could not completely remove it because the public API for
SstFileWriter takes a `skip_filters` parameter, and translating this
into an option change would mean awkwardly replacing the table_factory
if it is BlockBasedTableFactory with new filter_policy=nullptr option.
I marked this public skip_filters option as deprecated because of this
oddity. (skip_filters on the read side probably makes sense.)
At least `skip_filters` is now largely hidden for users of
`TableBuilderOptions` and is no longer used for implementing the
optimize_filters_for_hits option. Bringing the logic for that option
closer to handling of FilterBuildingContext makes it more obvious that
hese two are using the same notion of "bottommost." (Planned:
configuration options for Bloom-like filters that generalize
`optimize_filters_for_hits`)
Recommended follow-up: Try to get away from "bottommost level" naming of
things, which is inaccurate (see
VersionStorageInfo::RangeMightExistAfterSortedRun), and move to
"bottommost run" or just "bottommost."
Pull Request resolved: https://github.com/facebook/rocksdb/pull/8246
Test Plan:
extended an existing unit test to exercise and check various
filter building contexts. Also, existing tests for
optimize_filters_for_hits validate some of the "bottommost" handling,
which is now closely connected to FilterBuildingContext::is_bottommost
through TableBuilderOptions::is_bottommost
Reviewed By: mrambacher
Differential Revision: D28099346
Pulled By: pdillinger
fbshipit-source-id: 2c1072e29c24d4ac404c761a7b7663292372600a
2021-04-30 22:49:24 +02:00
|
|
|
sub_compact->compaction->output_compression_opts(), cfd->GetID(),
|
|
|
|
cfd->GetName(), sub_compact->compaction->output_level(),
|
|
|
|
bottommost_level_, TableFileCreationReason::kCompaction,
|
2021-04-29 15:59:53 +02:00
|
|
|
oldest_ancester_time, 0 /* oldest_key_time */, current_time, db_id_,
|
2021-06-10 20:01:44 +02:00
|
|
|
db_session_id_, sub_compact->compaction->max_output_file_size(),
|
|
|
|
file_number);
|
2021-04-29 15:59:53 +02:00
|
|
|
sub_compact->builder.reset(
|
|
|
|
NewTableBuilder(tboptions, sub_compact->outfile.get()));
|
2014-11-01 00:31:25 +01:00
|
|
|
LogFlush(db_options_.info_log);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
void CompactionJob::CleanupCompaction() {
|
2015-09-10 22:50:00 +02:00
|
|
|
for (SubcompactionState& sub_compact : compact_->sub_compact_states) {
|
2015-08-18 20:06:23 +02:00
|
|
|
const auto& sub_status = sub_compact.status;
|
2014-11-01 00:31:25 +01:00
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
if (sub_compact.builder != nullptr) {
|
|
|
|
// May happen if we get a shutdown call in the middle of compaction
|
|
|
|
sub_compact.builder->Abandon();
|
|
|
|
sub_compact.builder.reset();
|
|
|
|
} else {
|
|
|
|
assert(!sub_status.ok() || sub_compact.outfile == nullptr);
|
|
|
|
}
|
2015-09-10 23:35:25 +02:00
|
|
|
for (const auto& out : sub_compact.outputs) {
|
2015-08-18 20:06:23 +02:00
|
|
|
// If this file was inserted into the table cache then remove
|
|
|
|
// them here because this compaction was not committed.
|
|
|
|
if (!sub_status.ok()) {
|
2015-09-10 23:35:25 +02:00
|
|
|
TableCache::Evict(table_cache_.get(), out.meta.fd.GetNumber());
|
2015-08-18 20:06:23 +02:00
|
|
|
}
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
2020-09-25 06:47:43 +02:00
|
|
|
// TODO: sub_compact.io_status is not checked like status. Not sure if thats
|
|
|
|
// intentional. So ignoring the io_status as of now.
|
|
|
|
sub_compact.io_status.PermitUncheckedError();
|
2014-11-01 00:31:25 +01:00
|
|
|
}
|
|
|
|
delete compact_;
|
|
|
|
compact_ = nullptr;
|
|
|
|
}
|
|
|
|
|
2015-06-03 02:07:16 +02:00
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
namespace {
|
2018-04-13 02:55:14 +02:00
|
|
|
void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
|
2015-06-04 21:31:12 +02:00
|
|
|
assert(prefix_length > 0);
|
|
|
|
size_t length = src.size() > prefix_length ? prefix_length : src.size();
|
|
|
|
dst->assign(src.data(), length);
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
|
2015-07-14 09:09:20 +02:00
|
|
|
void CompactionJob::UpdateCompactionStats() {
|
2020-10-26 21:50:03 +01:00
|
|
|
assert(compact_);
|
|
|
|
|
2015-06-18 08:40:34 +02:00
|
|
|
Compaction* compaction = compact_->compaction;
|
|
|
|
compaction_stats_.num_input_files_in_non_output_levels = 0;
|
|
|
|
compaction_stats_.num_input_files_in_output_level = 0;
|
|
|
|
for (int input_level = 0;
|
|
|
|
input_level < static_cast<int>(compaction->num_input_levels());
|
|
|
|
++input_level) {
|
2016-11-29 19:49:47 +01:00
|
|
|
if (compaction->level(input_level) != compaction->output_level()) {
|
2015-06-18 08:40:34 +02:00
|
|
|
UpdateCompactionInputStatsHelper(
|
|
|
|
&compaction_stats_.num_input_files_in_non_output_levels,
|
2018-04-13 02:55:14 +02:00
|
|
|
&compaction_stats_.bytes_read_non_output_levels, input_level);
|
2015-06-18 08:40:34 +02:00
|
|
|
} else {
|
|
|
|
UpdateCompactionInputStatsHelper(
|
|
|
|
&compaction_stats_.num_input_files_in_output_level,
|
2018-04-13 02:55:14 +02:00
|
|
|
&compaction_stats_.bytes_read_output_level, input_level);
|
2015-06-18 08:40:34 +02:00
|
|
|
}
|
|
|
|
}
|
2015-07-14 09:09:20 +02:00
|
|
|
|
2021-03-04 09:42:11 +01:00
|
|
|
assert(compaction_job_stats_);
|
|
|
|
compaction_stats_.bytes_read_blob =
|
|
|
|
compaction_job_stats_->total_blob_bytes_read;
|
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
compaction_stats_.num_output_files =
|
2021-03-02 18:46:10 +01:00
|
|
|
static_cast<int>(compact_->num_output_files);
|
|
|
|
compaction_stats_.num_output_files_blob =
|
2020-10-26 21:50:03 +01:00
|
|
|
static_cast<int>(compact_->num_blob_output_files);
|
2021-03-02 18:46:10 +01:00
|
|
|
compaction_stats_.bytes_written = compact_->total_bytes;
|
|
|
|
compaction_stats_.bytes_written_blob = compact_->total_blob_bytes;
|
2020-01-24 00:25:23 +01:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
if (compaction_stats_.num_input_records > compact_->num_output_records) {
|
2020-01-24 00:25:23 +01:00
|
|
|
compaction_stats_.num_dropped_records =
|
2020-10-26 21:50:03 +01:00
|
|
|
compaction_stats_.num_input_records - compact_->num_output_records;
|
2015-07-14 09:09:20 +02:00
|
|
|
}
|
2015-06-18 08:40:34 +02:00
|
|
|
}
|
|
|
|
|
2018-04-13 02:55:14 +02:00
|
|
|
void CompactionJob::UpdateCompactionInputStatsHelper(int* num_files,
|
|
|
|
uint64_t* bytes_read,
|
|
|
|
int input_level) {
|
2015-06-18 08:40:34 +02:00
|
|
|
const Compaction* compaction = compact_->compaction;
|
|
|
|
auto num_input_files = compaction->num_input_files(input_level);
|
|
|
|
*num_files += static_cast<int>(num_input_files);
|
|
|
|
|
|
|
|
for (size_t i = 0; i < num_input_files; ++i) {
|
|
|
|
const auto* file_meta = compaction->input(input_level, i);
|
|
|
|
*bytes_read += file_meta->fd.GetFileSize();
|
|
|
|
compaction_stats_.num_input_records +=
|
|
|
|
static_cast<uint64_t>(file_meta->num_entries);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-03 02:07:16 +02:00
|
|
|
void CompactionJob::UpdateCompactionJobStats(
|
|
|
|
const InternalStats::CompactionStats& stats) const {
|
|
|
|
#ifndef ROCKSDB_LITE
|
2020-10-01 21:51:33 +02:00
|
|
|
compaction_job_stats_->elapsed_micros = stats.micros;
|
|
|
|
|
|
|
|
// input information
|
|
|
|
compaction_job_stats_->total_input_bytes =
|
|
|
|
stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
|
|
|
|
compaction_job_stats_->num_input_records = stats.num_input_records;
|
|
|
|
compaction_job_stats_->num_input_files =
|
|
|
|
stats.num_input_files_in_non_output_levels +
|
|
|
|
stats.num_input_files_in_output_level;
|
|
|
|
compaction_job_stats_->num_input_files_at_output_level =
|
|
|
|
stats.num_input_files_in_output_level;
|
|
|
|
|
|
|
|
// output information
|
2021-03-04 09:42:11 +01:00
|
|
|
compaction_job_stats_->total_output_bytes = stats.bytes_written;
|
|
|
|
compaction_job_stats_->total_output_bytes_blob = stats.bytes_written_blob;
|
2020-10-01 21:51:33 +02:00
|
|
|
compaction_job_stats_->num_output_records = compact_->num_output_records;
|
2021-03-04 09:42:11 +01:00
|
|
|
compaction_job_stats_->num_output_files = stats.num_output_files;
|
|
|
|
compaction_job_stats_->num_output_files_blob = stats.num_output_files_blob;
|
2020-10-01 21:51:33 +02:00
|
|
|
|
2020-10-26 21:50:03 +01:00
|
|
|
if (stats.num_output_files > 0) {
|
2020-10-01 21:51:33 +02:00
|
|
|
CopyPrefix(compact_->SmallestUserKey(),
|
|
|
|
CompactionJobStats::kMaxPrefixLength,
|
|
|
|
&compaction_job_stats_->smallest_output_key_prefix);
|
|
|
|
CopyPrefix(compact_->LargestUserKey(), CompactionJobStats::kMaxPrefixLength,
|
|
|
|
&compaction_job_stats_->largest_output_key_prefix);
|
2015-06-03 02:07:16 +02:00
|
|
|
}
|
2018-04-13 02:55:14 +02:00
|
|
|
#else
|
|
|
|
(void)stats;
|
2015-06-03 02:07:16 +02:00
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
}
|
|
|
|
|
2015-08-18 20:06:23 +02:00
|
|
|
void CompactionJob::LogCompaction() {
|
|
|
|
Compaction* compaction = compact_->compaction;
|
|
|
|
ColumnFamilyData* cfd = compaction->column_family_data();
|
|
|
|
|
2015-07-14 09:09:20 +02:00
|
|
|
// Let's check if anything will get logged. Don't prepare all the info if
|
|
|
|
// we're not logging
|
|
|
|
if (db_options_.info_log_level <= InfoLogLevel::INFO_LEVEL) {
|
|
|
|
Compaction::InputLevelSummaryBuffer inputs_summary;
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_INFO(
|
|
|
|
db_options_.info_log, "[%s] [JOB %d] Compacting %s, score %.2f",
|
|
|
|
cfd->GetName().c_str(), job_id_,
|
|
|
|
compaction->InputLevelSummary(&inputs_summary), compaction->score());
|
2015-07-14 09:09:20 +02:00
|
|
|
char scratch[2345];
|
|
|
|
compaction->Summary(scratch, sizeof(scratch));
|
2017-03-16 03:22:52 +01:00
|
|
|
ROCKS_LOG_INFO(db_options_.info_log, "[%s] Compaction start summary: %s\n",
|
|
|
|
cfd->GetName().c_str(), scratch);
|
2015-07-14 09:09:20 +02:00
|
|
|
// build event logger report
|
|
|
|
auto stream = event_logger_->Log();
|
2018-04-13 02:55:14 +02:00
|
|
|
stream << "job" << job_id_ << "event"
|
|
|
|
<< "compaction_started"
|
|
|
|
<< "compaction_reason"
|
|
|
|
<< GetCompactionReasonString(compaction->compaction_reason());
|
2015-07-14 09:09:20 +02:00
|
|
|
for (size_t i = 0; i < compaction->num_input_levels(); ++i) {
|
|
|
|
stream << ("files_L" + ToString(compaction->level(i)));
|
|
|
|
stream.StartArray();
|
|
|
|
for (auto f : *compaction->inputs(i)) {
|
|
|
|
stream << f->fd.GetNumber();
|
|
|
|
}
|
|
|
|
stream.EndArray();
|
|
|
|
}
|
|
|
|
stream << "score" << compaction->score() << "input_data_size"
|
|
|
|
<< compaction->CalculateTotalInputSize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-22 22:01:00 +02:00
|
|
|
std::string CompactionJob::GetTableFileName(uint64_t file_number) {
|
|
|
|
return TableFileName(compact_->compaction->immutable_cf_options()->cf_paths,
|
|
|
|
file_number, compact_->compaction->output_path_id());
|
|
|
|
}
|
|
|
|
|
2021-05-12 21:34:22 +02:00
|
|
|
#ifndef ROCKSDB_LITE
|
2021-04-22 22:01:00 +02:00
|
|
|
std::string CompactionServiceCompactionJob::GetTableFileName(
|
|
|
|
uint64_t file_number) {
|
|
|
|
return MakeTableFileName(output_path_, file_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
CompactionServiceCompactionJob::CompactionServiceCompactionJob(
|
|
|
|
int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
|
2021-05-20 06:40:43 +02:00
|
|
|
const MutableDBOptions& mutable_db_options, const FileOptions& file_options,
|
|
|
|
VersionSet* versions, const std::atomic<bool>* shutting_down,
|
|
|
|
LogBuffer* log_buffer, FSDirectory* output_directory, Statistics* stats,
|
2021-04-22 22:01:00 +02:00
|
|
|
InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
|
|
|
|
std::vector<SequenceNumber> existing_snapshots,
|
|
|
|
std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
|
|
|
|
const std::string& dbname, const std::shared_ptr<IOTracer>& io_tracer,
|
|
|
|
const std::string& db_id, const std::string& db_session_id,
|
|
|
|
const std::string& output_path,
|
|
|
|
const CompactionServiceInput& compaction_service_input,
|
|
|
|
CompactionServiceResult* compaction_service_result)
|
|
|
|
: CompactionJob(
|
2021-05-20 06:40:43 +02:00
|
|
|
job_id, compaction, db_options, mutable_db_options, file_options,
|
|
|
|
versions, shutting_down, 0, log_buffer, nullptr, output_directory,
|
|
|
|
nullptr, stats, db_mutex, db_error_handler, existing_snapshots,
|
|
|
|
kMaxSequenceNumber, nullptr, table_cache, event_logger,
|
2021-04-22 22:01:00 +02:00
|
|
|
compaction->mutable_cf_options()->paranoid_file_checks,
|
|
|
|
compaction->mutable_cf_options()->report_bg_io_stats, dbname,
|
|
|
|
&(compaction_service_result->stats), Env::Priority::USER, io_tracer,
|
2021-06-07 20:40:31 +02:00
|
|
|
nullptr, nullptr, db_id, db_session_id,
|
2021-04-22 22:01:00 +02:00
|
|
|
compaction->column_family_data()->GetFullHistoryTsLow()),
|
|
|
|
output_path_(output_path),
|
|
|
|
compaction_input_(compaction_service_input),
|
|
|
|
compaction_result_(compaction_service_result) {}
|
|
|
|
|
|
|
|
Status CompactionServiceCompactionJob::Run() {
|
|
|
|
AutoThreadOperationStageUpdater stage_updater(
|
|
|
|
ThreadStatus::STAGE_COMPACTION_RUN);
|
|
|
|
|
|
|
|
auto* c = compact_->compaction;
|
|
|
|
assert(c->column_family_data() != nullptr);
|
|
|
|
assert(c->column_family_data()->current()->storage_info()->NumLevelFiles(
|
|
|
|
compact_->compaction->level()) > 0);
|
|
|
|
|
|
|
|
write_hint_ =
|
|
|
|
c->column_family_data()->CalculateSSTWriteHint(c->output_level());
|
|
|
|
bottommost_level_ = c->bottommost_level();
|
|
|
|
|
2021-05-12 21:34:22 +02:00
|
|
|
Slice begin = compaction_input_.begin;
|
|
|
|
Slice end = compaction_input_.end;
|
|
|
|
compact_->sub_compact_states.emplace_back(
|
|
|
|
c, compaction_input_.has_begin ? &begin : nullptr,
|
|
|
|
compaction_input_.has_end ? &end : nullptr,
|
|
|
|
compaction_input_.approx_size);
|
2021-04-22 22:01:00 +02:00
|
|
|
|
|
|
|
log_buffer_->FlushBufferToLog();
|
|
|
|
LogCompaction();
|
|
|
|
const uint64_t start_micros = db_options_.clock->NowMicros();
|
|
|
|
// Pick the only sub-compaction we should have
|
|
|
|
assert(compact_->sub_compact_states.size() == 1);
|
|
|
|
SubcompactionState* sub_compact = compact_->sub_compact_states.data();
|
|
|
|
|
|
|
|
ProcessKeyValueCompaction(sub_compact);
|
|
|
|
|
|
|
|
compaction_stats_.micros = db_options_.clock->NowMicros() - start_micros;
|
|
|
|
compaction_stats_.cpu_micros = sub_compact->compaction_job_stats.cpu_micros;
|
|
|
|
|
|
|
|
RecordTimeToHistogram(stats_, COMPACTION_TIME, compaction_stats_.micros);
|
|
|
|
RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
|
|
|
|
compaction_stats_.cpu_micros);
|
|
|
|
|
|
|
|
Status status = sub_compact->status;
|
|
|
|
IOStatus io_s = sub_compact->io_status;
|
|
|
|
|
|
|
|
if (io_status_.ok()) {
|
|
|
|
io_status_ = io_s;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status.ok()) {
|
|
|
|
constexpr IODebugContext* dbg = nullptr;
|
|
|
|
|
|
|
|
if (output_directory_) {
|
|
|
|
io_s = output_directory_->Fsync(IOOptions(), dbg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (io_status_.ok()) {
|
|
|
|
io_status_ = io_s;
|
|
|
|
}
|
|
|
|
if (status.ok()) {
|
|
|
|
status = io_s;
|
|
|
|
}
|
|
|
|
if (status.ok()) {
|
|
|
|
// TODO: Add verify_table() and VerifyCompactionFileConsistency()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finish up all book-keeping to unify the subcompaction results
|
|
|
|
AggregateStatistics();
|
|
|
|
UpdateCompactionStats();
|
|
|
|
|
|
|
|
compaction_result_->bytes_written = IOSTATS(bytes_written);
|
|
|
|
compaction_result_->bytes_read = IOSTATS(bytes_read);
|
|
|
|
RecordCompactionIOStats();
|
|
|
|
|
|
|
|
LogFlush(db_options_.info_log);
|
|
|
|
compact_->status = status;
|
|
|
|
compact_->status.PermitUncheckedError();
|
|
|
|
|
|
|
|
// Build compaction result
|
|
|
|
compaction_result_->output_level = compact_->compaction->output_level();
|
|
|
|
compaction_result_->output_path = output_path_;
|
|
|
|
for (const auto& output_file : sub_compact->outputs) {
|
|
|
|
auto& meta = output_file.meta;
|
|
|
|
compaction_result_->output_files.emplace_back(
|
|
|
|
MakeTableFileName(meta.fd.GetNumber()), meta.fd.smallest_seqno,
|
|
|
|
meta.fd.largest_seqno, meta.smallest.Encode().ToString(),
|
|
|
|
meta.largest.Encode().ToString(), meta.oldest_ancester_time,
|
|
|
|
meta.file_creation_time, output_file.validator.GetHash(),
|
|
|
|
meta.marked_for_compaction);
|
|
|
|
}
|
|
|
|
compaction_result_->num_output_records = sub_compact->num_output_records;
|
|
|
|
compaction_result_->total_bytes = sub_compact->total_bytes;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CompactionServiceCompactionJob::CleanupCompaction() {
|
|
|
|
CompactionJob::CleanupCompaction();
|
|
|
|
}
|
|
|
|
|
2021-05-12 21:34:22 +02:00
|
|
|
// Internal binary format for the input and result data
|
|
|
|
enum BinaryFormatVersion : uint32_t {
|
|
|
|
kOptionsString = 1, // Use string format similar to Option string format
|
|
|
|
};
|
|
|
|
|
|
|
|
// offset_of is used to get the offset of a class data member
|
|
|
|
// ex: offset_of(&ColumnFamilyDescriptor::options)
|
|
|
|
// This call will return the offset of options in ColumnFamilyDescriptor class
|
|
|
|
//
|
|
|
|
// This is the same as offsetof() but allow us to work with non standard-layout
|
|
|
|
// classes and structures
|
|
|
|
// refs:
|
|
|
|
// http://en.cppreference.com/w/cpp/concept/StandardLayoutType
|
|
|
|
// https://gist.github.com/graphitemaster/494f21190bb2c63c5516
|
|
|
|
static ColumnFamilyDescriptor dummy_cfd("", ColumnFamilyOptions());
|
|
|
|
template <typename T1>
|
|
|
|
int offset_of(T1 ColumnFamilyDescriptor::*member) {
|
|
|
|
return int(size_t(&(dummy_cfd.*member)) - size_t(&dummy_cfd));
|
|
|
|
}
|
|
|
|
|
|
|
|
static CompactionServiceInput dummy_cs_input;
|
|
|
|
template <typename T1>
|
|
|
|
int offset_of(T1 CompactionServiceInput::*member) {
|
|
|
|
return int(size_t(&(dummy_cs_input.*member)) - size_t(&dummy_cs_input));
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::unordered_map<std::string, OptionTypeInfo> cfd_type_info = {
|
|
|
|
{"name",
|
|
|
|
{offset_of(&ColumnFamilyDescriptor::name), OptionType::kEncodedString,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"options",
|
|
|
|
{offset_of(&ColumnFamilyDescriptor::options), OptionType::kConfigurable,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone,
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
2021-05-13 23:28:50 +02:00
|
|
|
const std::string& value, void* addr) {
|
|
|
|
auto cf_options = static_cast<ColumnFamilyOptions*>(addr);
|
2021-05-12 21:34:22 +02:00
|
|
|
return GetColumnFamilyOptionsFromString(opts, ColumnFamilyOptions(),
|
|
|
|
value, cf_options);
|
|
|
|
},
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
2021-05-13 23:28:50 +02:00
|
|
|
const void* addr, std::string* value) {
|
|
|
|
const auto cf_options = static_cast<const ColumnFamilyOptions*>(addr);
|
2021-05-12 21:34:22 +02:00
|
|
|
std::string result;
|
|
|
|
auto status =
|
|
|
|
GetStringFromColumnFamilyOptions(opts, *cf_options, &result);
|
|
|
|
*value = "{" + result + "}";
|
|
|
|
return status;
|
|
|
|
},
|
2021-05-13 23:28:50 +02:00
|
|
|
[](const ConfigOptions& opts, const std::string& name, const void* addr1,
|
|
|
|
const void* addr2, std::string* mismatch) {
|
|
|
|
const auto this_one = static_cast<const ColumnFamilyOptions*>(addr1);
|
|
|
|
const auto that_one = static_cast<const ColumnFamilyOptions*>(addr2);
|
2021-05-12 21:34:22 +02:00
|
|
|
auto this_conf = CFOptionsAsConfigurable(*this_one);
|
|
|
|
auto that_conf = CFOptionsAsConfigurable(*that_one);
|
|
|
|
std::string mismatch_opt;
|
|
|
|
bool result =
|
|
|
|
this_conf->AreEquivalent(opts, that_conf.get(), &mismatch_opt);
|
|
|
|
if (!result) {
|
|
|
|
*mismatch = name + "." + mismatch_opt;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}}},
|
|
|
|
};
|
|
|
|
|
|
|
|
static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
|
|
|
|
{"column_family",
|
|
|
|
OptionTypeInfo::Struct("column_family", &cfd_type_info,
|
|
|
|
offset_of(&CompactionServiceInput::column_family),
|
|
|
|
OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone)},
|
|
|
|
{"db_options",
|
|
|
|
{offset_of(&CompactionServiceInput::db_options), OptionType::kConfigurable,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone,
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
2021-05-13 23:28:50 +02:00
|
|
|
const std::string& value, void* addr) {
|
|
|
|
auto options = static_cast<DBOptions*>(addr);
|
2021-05-12 21:34:22 +02:00
|
|
|
return GetDBOptionsFromString(opts, DBOptions(), value, options);
|
|
|
|
},
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
2021-05-13 23:28:50 +02:00
|
|
|
const void* addr, std::string* value) {
|
|
|
|
const auto options = static_cast<const DBOptions*>(addr);
|
2021-05-12 21:34:22 +02:00
|
|
|
std::string result;
|
|
|
|
auto status = GetStringFromDBOptions(opts, *options, &result);
|
|
|
|
*value = "{" + result + "}";
|
|
|
|
return status;
|
|
|
|
},
|
2021-05-13 23:28:50 +02:00
|
|
|
[](const ConfigOptions& opts, const std::string& name, const void* addr1,
|
|
|
|
const void* addr2, std::string* mismatch) {
|
|
|
|
const auto this_one = static_cast<const DBOptions*>(addr1);
|
|
|
|
const auto that_one = static_cast<const DBOptions*>(addr2);
|
2021-05-12 21:34:22 +02:00
|
|
|
auto this_conf = DBOptionsAsConfigurable(*this_one);
|
|
|
|
auto that_conf = DBOptionsAsConfigurable(*that_one);
|
|
|
|
std::string mismatch_opt;
|
|
|
|
bool result =
|
|
|
|
this_conf->AreEquivalent(opts, that_conf.get(), &mismatch_opt);
|
|
|
|
if (!result) {
|
|
|
|
*mismatch = name + "." + mismatch_opt;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}}},
|
|
|
|
{"snapshots", OptionTypeInfo::Vector<uint64_t>(
|
|
|
|
offset_of(&CompactionServiceInput::snapshots),
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone,
|
|
|
|
{0, OptionType::kUInt64T})},
|
|
|
|
{"input_files", OptionTypeInfo::Vector<std::string>(
|
|
|
|
offset_of(&CompactionServiceInput::input_files),
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone,
|
|
|
|
{0, OptionType::kEncodedString})},
|
|
|
|
{"output_level",
|
|
|
|
{offset_of(&CompactionServiceInput::output_level), OptionType::kInt,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"has_begin",
|
|
|
|
{offset_of(&CompactionServiceInput::has_begin), OptionType::kBoolean,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"begin",
|
|
|
|
{offset_of(&CompactionServiceInput::begin), OptionType::kEncodedString,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"has_end",
|
|
|
|
{offset_of(&CompactionServiceInput::has_end), OptionType::kBoolean,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"end",
|
|
|
|
{offset_of(&CompactionServiceInput::end), OptionType::kEncodedString,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"approx_size",
|
|
|
|
{offset_of(&CompactionServiceInput::approx_size), OptionType::kUInt64T,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
};
|
|
|
|
|
|
|
|
static std::unordered_map<std::string, OptionTypeInfo>
|
|
|
|
cs_output_file_type_info = {
|
|
|
|
{"file_name",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, file_name),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"smallest_seqno",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, smallest_seqno),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"largest_seqno",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, largest_seqno),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"smallest_internal_key",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, smallest_internal_key),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"largest_internal_key",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, largest_internal_key),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"oldest_ancester_time",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, oldest_ancester_time),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"file_creation_time",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, file_creation_time),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"paranoid_hash",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, paranoid_hash),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"marked_for_compaction",
|
|
|
|
{offsetof(struct CompactionServiceOutputFile, marked_for_compaction),
|
|
|
|
OptionType::kBoolean, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
};
|
|
|
|
|
|
|
|
static std::unordered_map<std::string, OptionTypeInfo>
|
|
|
|
compaction_job_stats_type_info = {
|
|
|
|
{"elapsed_micros",
|
|
|
|
{offsetof(struct CompactionJobStats, elapsed_micros),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"cpu_micros",
|
|
|
|
{offsetof(struct CompactionJobStats, cpu_micros), OptionType::kUInt64T,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"num_input_records",
|
|
|
|
{offsetof(struct CompactionJobStats, num_input_records),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_blobs_read",
|
|
|
|
{offsetof(struct CompactionJobStats, num_blobs_read),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_input_files",
|
|
|
|
{offsetof(struct CompactionJobStats, num_input_files),
|
|
|
|
OptionType::kSizeT, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_input_files_at_output_level",
|
|
|
|
{offsetof(struct CompactionJobStats, num_input_files_at_output_level),
|
|
|
|
OptionType::kSizeT, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_output_records",
|
|
|
|
{offsetof(struct CompactionJobStats, num_output_records),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_output_files",
|
|
|
|
{offsetof(struct CompactionJobStats, num_output_files),
|
|
|
|
OptionType::kSizeT, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_output_files_blob",
|
|
|
|
{offsetof(struct CompactionJobStats, num_output_files_blob),
|
|
|
|
OptionType::kSizeT, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"is_full_compaction",
|
|
|
|
{offsetof(struct CompactionJobStats, is_full_compaction),
|
|
|
|
OptionType::kBoolean, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"is_manual_compaction",
|
|
|
|
{offsetof(struct CompactionJobStats, is_manual_compaction),
|
|
|
|
OptionType::kBoolean, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_input_bytes",
|
|
|
|
{offsetof(struct CompactionJobStats, total_input_bytes),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_blob_bytes_read",
|
|
|
|
{offsetof(struct CompactionJobStats, total_blob_bytes_read),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_output_bytes",
|
|
|
|
{offsetof(struct CompactionJobStats, total_output_bytes),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_output_bytes_blob",
|
|
|
|
{offsetof(struct CompactionJobStats, total_output_bytes_blob),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_records_replaced",
|
|
|
|
{offsetof(struct CompactionJobStats, num_records_replaced),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_input_raw_key_bytes",
|
|
|
|
{offsetof(struct CompactionJobStats, total_input_raw_key_bytes),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_input_raw_value_bytes",
|
|
|
|
{offsetof(struct CompactionJobStats, total_input_raw_value_bytes),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_input_deletion_records",
|
|
|
|
{offsetof(struct CompactionJobStats, num_input_deletion_records),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_expired_deletion_records",
|
|
|
|
{offsetof(struct CompactionJobStats, num_expired_deletion_records),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_corrupt_keys",
|
|
|
|
{offsetof(struct CompactionJobStats, num_corrupt_keys),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"file_write_nanos",
|
|
|
|
{offsetof(struct CompactionJobStats, file_write_nanos),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"file_range_sync_nanos",
|
|
|
|
{offsetof(struct CompactionJobStats, file_range_sync_nanos),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"file_fsync_nanos",
|
|
|
|
{offsetof(struct CompactionJobStats, file_fsync_nanos),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"file_prepare_write_nanos",
|
|
|
|
{offsetof(struct CompactionJobStats, file_prepare_write_nanos),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"smallest_output_key_prefix",
|
|
|
|
{offsetof(struct CompactionJobStats, smallest_output_key_prefix),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"largest_output_key_prefix",
|
|
|
|
{offsetof(struct CompactionJobStats, largest_output_key_prefix),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_single_del_fallthru",
|
|
|
|
{offsetof(struct CompactionJobStats, num_single_del_fallthru),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_single_del_mismatch",
|
|
|
|
{offsetof(struct CompactionJobStats, num_single_del_mismatch),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
};
|
|
|
|
|
2021-05-20 06:40:43 +02:00
|
|
|
namespace {
|
|
|
|
// this is a helper struct to serialize and deserialize class Status, because
|
|
|
|
// Status's members are not public.
|
|
|
|
struct StatusSerializationAdapter {
|
|
|
|
uint8_t code;
|
|
|
|
uint8_t subcode;
|
|
|
|
uint8_t severity;
|
|
|
|
std::string message;
|
|
|
|
|
|
|
|
StatusSerializationAdapter() {}
|
|
|
|
explicit StatusSerializationAdapter(const Status& s) {
|
|
|
|
code = s.code();
|
|
|
|
subcode = s.subcode();
|
|
|
|
severity = s.severity();
|
|
|
|
auto msg = s.getState();
|
|
|
|
message = msg ? msg : "";
|
|
|
|
}
|
|
|
|
|
|
|
|
Status GetStatus() {
|
|
|
|
return Status(static_cast<Status::Code>(code),
|
|
|
|
static_cast<Status::SubCode>(subcode),
|
|
|
|
static_cast<Status::Severity>(severity), message);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
static std::unordered_map<std::string, OptionTypeInfo>
|
|
|
|
status_adapter_type_info = {
|
|
|
|
{"code",
|
|
|
|
{offsetof(struct StatusSerializationAdapter, code),
|
|
|
|
OptionType::kUInt8T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"subcode",
|
|
|
|
{offsetof(struct StatusSerializationAdapter, subcode),
|
|
|
|
OptionType::kUInt8T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"severity",
|
|
|
|
{offsetof(struct StatusSerializationAdapter, severity),
|
|
|
|
OptionType::kUInt8T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"message",
|
|
|
|
{offsetof(struct StatusSerializationAdapter, message),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
};
|
|
|
|
|
2021-05-12 21:34:22 +02:00
|
|
|
static std::unordered_map<std::string, OptionTypeInfo> cs_result_type_info = {
|
2021-05-20 06:40:43 +02:00
|
|
|
{"status",
|
|
|
|
{offsetof(struct CompactionServiceResult, status),
|
|
|
|
OptionType::kCustomizable, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone,
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
|
|
|
const std::string& value, void* addr) {
|
|
|
|
auto status_obj = static_cast<Status*>(addr);
|
|
|
|
StatusSerializationAdapter adapter;
|
|
|
|
Status s = OptionTypeInfo::ParseType(
|
|
|
|
opts, value, status_adapter_type_info, &adapter);
|
|
|
|
*status_obj = adapter.GetStatus();
|
|
|
|
return s;
|
|
|
|
},
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
|
|
|
const void* addr, std::string* value) {
|
|
|
|
const auto status_obj = static_cast<const Status*>(addr);
|
|
|
|
StatusSerializationAdapter adapter(*status_obj);
|
|
|
|
std::string result;
|
|
|
|
Status s = OptionTypeInfo::SerializeType(opts, status_adapter_type_info,
|
|
|
|
&adapter, &result);
|
|
|
|
*value = "{" + result + "}";
|
|
|
|
return s;
|
|
|
|
},
|
|
|
|
[](const ConfigOptions& opts, const std::string& /*name*/,
|
|
|
|
const void* addr1, const void* addr2, std::string* mismatch) {
|
|
|
|
const auto status1 = static_cast<const Status*>(addr1);
|
|
|
|
const auto status2 = static_cast<const Status*>(addr2);
|
|
|
|
StatusSerializationAdapter adatper1(*status1);
|
|
|
|
StatusSerializationAdapter adapter2(*status2);
|
|
|
|
return OptionTypeInfo::TypesAreEqual(opts, status_adapter_type_info,
|
|
|
|
&adatper1, &adapter2, mismatch);
|
|
|
|
}}},
|
2021-05-12 21:34:22 +02:00
|
|
|
{"output_files",
|
|
|
|
OptionTypeInfo::Vector<CompactionServiceOutputFile>(
|
|
|
|
offsetof(struct CompactionServiceResult, output_files),
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone,
|
|
|
|
OptionTypeInfo::Struct("output_files", &cs_output_file_type_info, 0,
|
|
|
|
OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone))},
|
|
|
|
{"output_level",
|
|
|
|
{offsetof(struct CompactionServiceResult, output_level), OptionType::kInt,
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
|
|
|
|
{"output_path",
|
|
|
|
{offsetof(struct CompactionServiceResult, output_path),
|
|
|
|
OptionType::kEncodedString, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"num_output_records",
|
|
|
|
{offsetof(struct CompactionServiceResult, num_output_records),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"total_bytes",
|
|
|
|
{offsetof(struct CompactionServiceResult, total_bytes),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"bytes_read",
|
|
|
|
{offsetof(struct CompactionServiceResult, bytes_read),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"bytes_written",
|
|
|
|
{offsetof(struct CompactionServiceResult, bytes_written),
|
|
|
|
OptionType::kUInt64T, OptionVerificationType::kNormal,
|
|
|
|
OptionTypeFlags::kNone}},
|
|
|
|
{"stats", OptionTypeInfo::Struct(
|
|
|
|
"stats", &compaction_job_stats_type_info,
|
|
|
|
offsetof(struct CompactionServiceResult, stats),
|
|
|
|
OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
|
|
|
|
};
|
|
|
|
|
|
|
|
Status CompactionServiceInput::Read(const std::string& data_str,
|
|
|
|
CompactionServiceInput* obj) {
|
2021-05-20 06:40:43 +02:00
|
|
|
if (data_str.size() <= sizeof(BinaryFormatVersion)) {
|
|
|
|
return Status::InvalidArgument("Invalid CompactionServiceInput string");
|
|
|
|
}
|
2021-05-12 21:34:22 +02:00
|
|
|
auto format_version = DecodeFixed32(data_str.data());
|
|
|
|
if (format_version == kOptionsString) {
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
cf.ignore_unknown_options = true;
|
|
|
|
return OptionTypeInfo::ParseType(
|
|
|
|
cf, data_str.substr(sizeof(BinaryFormatVersion)), cs_input_type_info,
|
|
|
|
obj);
|
|
|
|
} else {
|
|
|
|
return Status::NotSupported(
|
|
|
|
"Compaction Service Input data version not supported: " +
|
|
|
|
ToString(format_version));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Status CompactionServiceInput::Write(std::string* output) {
|
|
|
|
char buf[sizeof(BinaryFormatVersion)];
|
|
|
|
EncodeFixed32(buf, kOptionsString);
|
|
|
|
output->append(buf, sizeof(BinaryFormatVersion));
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
return OptionTypeInfo::SerializeType(cf, cs_input_type_info, this, output);
|
|
|
|
}
|
|
|
|
|
|
|
|
Status CompactionServiceResult::Read(const std::string& data_str,
|
|
|
|
CompactionServiceResult* obj) {
|
2021-05-20 06:40:43 +02:00
|
|
|
if (data_str.size() <= sizeof(BinaryFormatVersion)) {
|
|
|
|
return Status::InvalidArgument("Invalid CompactionServiceResult string");
|
|
|
|
}
|
2021-05-12 21:34:22 +02:00
|
|
|
auto format_version = DecodeFixed32(data_str.data());
|
|
|
|
if (format_version == kOptionsString) {
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
cf.ignore_unknown_options = true;
|
|
|
|
return OptionTypeInfo::ParseType(
|
|
|
|
cf, data_str.substr(sizeof(BinaryFormatVersion)), cs_result_type_info,
|
|
|
|
obj);
|
|
|
|
} else {
|
|
|
|
return Status::NotSupported(
|
|
|
|
"Compaction Service Result data version not supported: " +
|
|
|
|
ToString(format_version));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Status CompactionServiceResult::Write(std::string* output) {
|
|
|
|
char buf[sizeof(BinaryFormatVersion)];
|
|
|
|
EncodeFixed32(buf, kOptionsString);
|
|
|
|
output->append(buf, sizeof(BinaryFormatVersion));
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
return OptionTypeInfo::SerializeType(cf, cs_result_type_info, this, output);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
bool CompactionServiceResult::TEST_Equals(CompactionServiceResult* other) {
|
|
|
|
std::string mismatch;
|
|
|
|
return TEST_Equals(other, &mismatch);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CompactionServiceResult::TEST_Equals(CompactionServiceResult* other,
|
|
|
|
std::string* mismatch) {
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
return OptionTypeInfo::TypesAreEqual(cf, cs_result_type_info, this, other,
|
|
|
|
mismatch);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CompactionServiceInput::TEST_Equals(CompactionServiceInput* other) {
|
|
|
|
std::string mismatch;
|
|
|
|
return TEST_Equals(other, &mismatch);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CompactionServiceInput::TEST_Equals(CompactionServiceInput* other,
|
|
|
|
std::string* mismatch) {
|
|
|
|
ConfigOptions cf;
|
|
|
|
cf.invoke_prepare_options = false;
|
|
|
|
return OptionTypeInfo::TypesAreEqual(cf, cs_input_type_info, this, other,
|
|
|
|
mismatch);
|
|
|
|
}
|
|
|
|
#endif // NDEBUG
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
|
2020-02-20 21:07:53 +01:00
|
|
|
} // namespace ROCKSDB_NAMESPACE
|