Summary: I'm sure we'll all agree that version_set.cc needs simplifying. This diff moves Compaction class to a separate file. The diff depends on D15171 and D15183 Test Plan: make check Reviewers: dhruba, haobo, kailiu, sdong Reviewed By: kailiu CC: leveldb Differential Revision: https://reviews.facebook.net/D15189main
Igor Canadi
11 years ago
parent
2f4eda7890
commit
615d1ea2f4
@ -0,0 +1,214 @@ |
|||||||
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under the BSD-style license found in the
|
||||||
|
// LICENSE file in the root directory of this source tree. An additional grant
|
||||||
|
// of patent rights can be found in the PATENTS file in the same directory.
|
||||||
|
//
|
||||||
|
// 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.
|
||||||
|
|
||||||
|
#include "db/compaction.h" |
||||||
|
|
||||||
|
namespace rocksdb { |
||||||
|
|
||||||
|
static uint64_t TotalFileSize(const std::vector<FileMetaData*>& files) { |
||||||
|
uint64_t sum = 0; |
||||||
|
for (size_t i = 0; i < files.size() && files[i]; i++) { |
||||||
|
sum += files[i]->file_size; |
||||||
|
} |
||||||
|
return sum; |
||||||
|
} |
||||||
|
|
||||||
|
Compaction::Compaction(Version* input_version, int level, int out_level, |
||||||
|
uint64_t target_file_size, |
||||||
|
uint64_t max_grandparent_overlap_bytes, |
||||||
|
bool seek_compaction, bool enable_compression) |
||||||
|
: level_(level), |
||||||
|
out_level_(out_level), |
||||||
|
max_output_file_size_(target_file_size), |
||||||
|
maxGrandParentOverlapBytes_(max_grandparent_overlap_bytes), |
||||||
|
input_version_(input_version), |
||||||
|
number_levels_(input_version_->NumberLevels()), |
||||||
|
seek_compaction_(seek_compaction), |
||||||
|
enable_compression_(enable_compression), |
||||||
|
grandparent_index_(0), |
||||||
|
seen_key_(false), |
||||||
|
overlapped_bytes_(0), |
||||||
|
base_index_(-1), |
||||||
|
parent_index_(-1), |
||||||
|
score_(0), |
||||||
|
bottommost_level_(false), |
||||||
|
is_full_compaction_(false), |
||||||
|
level_ptrs_(std::vector<size_t>(number_levels_)) { |
||||||
|
|
||||||
|
input_version_->Ref(); |
||||||
|
edit_ = new VersionEdit(); |
||||||
|
for (int i = 0; i < number_levels_; i++) { |
||||||
|
level_ptrs_[i] = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Compaction::~Compaction() { |
||||||
|
delete edit_; |
||||||
|
if (input_version_ != nullptr) { |
||||||
|
input_version_->Unref(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
bool Compaction::IsTrivialMove() const { |
||||||
|
// Avoid a move if there is lots of overlapping grandparent data.
|
||||||
|
// Otherwise, the move could create a parent file that will require
|
||||||
|
// a very expensive merge later on.
|
||||||
|
// If level_== out_level_, the purpose is to force compaction filter to be
|
||||||
|
// applied to that level, and thus cannot be a trivia move.
|
||||||
|
return (level_ != out_level_ && |
||||||
|
num_input_files(0) == 1 && |
||||||
|
num_input_files(1) == 0 && |
||||||
|
TotalFileSize(grandparents_) <= maxGrandParentOverlapBytes_); |
||||||
|
} |
||||||
|
|
||||||
|
void Compaction::AddInputDeletions(VersionEdit* edit) { |
||||||
|
for (int which = 0; which < 2; which++) { |
||||||
|
for (size_t i = 0; i < inputs_[which].size(); i++) { |
||||||
|
edit->DeleteFile(level_ + which, inputs_[which][i]->number); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
bool Compaction::IsBaseLevelForKey(const Slice& user_key) { |
||||||
|
if (input_version_->vset_->options_->compaction_style == |
||||||
|
kCompactionStyleUniversal) { |
||||||
|
return bottommost_level_; |
||||||
|
} |
||||||
|
// Maybe use binary search to find right entry instead of linear search?
|
||||||
|
const Comparator* user_cmp = input_version_->vset_->icmp_.user_comparator(); |
||||||
|
for (int lvl = level_ + 2; lvl < number_levels_; lvl++) { |
||||||
|
const std::vector<FileMetaData*>& files = input_version_->files_[lvl]; |
||||||
|
for (; level_ptrs_[lvl] < files.size(); ) { |
||||||
|
FileMetaData* f = files[level_ptrs_[lvl]]; |
||||||
|
if (user_cmp->Compare(user_key, f->largest.user_key()) <= 0) { |
||||||
|
// We've advanced far enough
|
||||||
|
if (user_cmp->Compare(user_key, f->smallest.user_key()) >= 0) { |
||||||
|
// Key falls in this file's range, so definitely not base level
|
||||||
|
return false; |
||||||
|
} |
||||||
|
break; |
||||||
|
} |
||||||
|
level_ptrs_[lvl]++; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
bool Compaction::ShouldStopBefore(const Slice& internal_key) { |
||||||
|
// Scan to find earliest grandparent file that contains key.
|
||||||
|
const InternalKeyComparator* icmp = &input_version_->vset_->icmp_; |
||||||
|
while (grandparent_index_ < grandparents_.size() && |
||||||
|
icmp->Compare(internal_key, |
||||||
|
grandparents_[grandparent_index_]->largest.Encode()) > 0) { |
||||||
|
if (seen_key_) { |
||||||
|
overlapped_bytes_ += grandparents_[grandparent_index_]->file_size; |
||||||
|
} |
||||||
|
assert(grandparent_index_ + 1 >= grandparents_.size() || |
||||||
|
icmp->Compare(grandparents_[grandparent_index_]->largest.Encode(), |
||||||
|
grandparents_[grandparent_index_+1]->smallest.Encode()) |
||||||
|
< 0); |
||||||
|
grandparent_index_++; |
||||||
|
} |
||||||
|
seen_key_ = true; |
||||||
|
|
||||||
|
if (overlapped_bytes_ > maxGrandParentOverlapBytes_) { |
||||||
|
// Too much overlap for current output; start new output
|
||||||
|
overlapped_bytes_ = 0; |
||||||
|
return true; |
||||||
|
} else { |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Mark (or clear) each file that is being compacted
|
||||||
|
void Compaction::MarkFilesBeingCompacted(bool value) { |
||||||
|
for (int i = 0; i < 2; i++) { |
||||||
|
std::vector<FileMetaData*> v = inputs_[i]; |
||||||
|
for (unsigned int j = 0; j < inputs_[i].size(); j++) { |
||||||
|
assert(value ? !inputs_[i][j]->being_compacted : |
||||||
|
inputs_[i][j]->being_compacted); |
||||||
|
inputs_[i][j]->being_compacted = value; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Is this compaction producing files at the bottommost level?
|
||||||
|
void Compaction::SetupBottomMostLevel(bool isManual) { |
||||||
|
if (input_version_->vset_->options_->compaction_style == |
||||||
|
kCompactionStyleUniversal) { |
||||||
|
// If universal compaction style is used and manual
|
||||||
|
// compaction is occuring, then we are guaranteed that
|
||||||
|
// all files will be picked in a single compaction
|
||||||
|
// run. We can safely set bottommost_level_ = true.
|
||||||
|
// If it is not manual compaction, then bottommost_level_
|
||||||
|
// is already set when the Compaction was created.
|
||||||
|
if (isManual) { |
||||||
|
bottommost_level_ = true; |
||||||
|
} |
||||||
|
return; |
||||||
|
} |
||||||
|
bottommost_level_ = true; |
||||||
|
int num_levels = input_version_->vset_->NumberLevels(); |
||||||
|
for (int i = output_level() + 1; i < num_levels; i++) { |
||||||
|
if (input_version_->NumLevelFiles(i) > 0) { |
||||||
|
bottommost_level_ = false; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void Compaction::ReleaseInputs() { |
||||||
|
if (input_version_ != nullptr) { |
||||||
|
input_version_->Unref(); |
||||||
|
input_version_ = nullptr; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void Compaction::ResetNextCompactionIndex() { |
||||||
|
input_version_->ResetNextCompactionIndex(level_); |
||||||
|
} |
||||||
|
|
||||||
|
static void InputSummary(std::vector<FileMetaData*>& files, char* output, |
||||||
|
int len) { |
||||||
|
int write = 0; |
||||||
|
for (unsigned int i = 0; i < files.size(); i++) { |
||||||
|
int sz = len - write; |
||||||
|
int ret = snprintf(output + write, sz, "%lu(%lu) ", |
||||||
|
(unsigned long)files.at(i)->number, |
||||||
|
(unsigned long)files.at(i)->file_size); |
||||||
|
if (ret < 0 || ret >= sz) |
||||||
|
break; |
||||||
|
write += ret; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void Compaction::Summary(char* output, int len) { |
||||||
|
int write = snprintf(output, len, |
||||||
|
"Base version %lu Base level %d, seek compaction:%d, inputs:", |
||||||
|
(unsigned long)input_version_->GetVersionNumber(), |
||||||
|
level_, |
||||||
|
seek_compaction_); |
||||||
|
if (write < 0 || write > len) { |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
char level_low_summary[100]; |
||||||
|
InputSummary(inputs_[0], level_low_summary, sizeof(level_low_summary)); |
||||||
|
char level_up_summary[100]; |
||||||
|
if (inputs_[1].size()) { |
||||||
|
InputSummary(inputs_[1], level_up_summary, sizeof(level_up_summary)); |
||||||
|
} else { |
||||||
|
level_up_summary[0] = '\0'; |
||||||
|
} |
||||||
|
|
||||||
|
snprintf(output + write, len - write, "[%s],[%s]", |
||||||
|
level_low_summary, level_up_summary); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace rocksdb
|
||||||
@ -0,0 +1,131 @@ |
|||||||
|
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under the BSD-style license found in the
|
||||||
|
// LICENSE file in the root directory of this source tree. An additional grant
|
||||||
|
// of patent rights can be found in the PATENTS file in the same directory.
|
||||||
|
//
|
||||||
|
// 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.
|
||||||
|
|
||||||
|
#pragma once |
||||||
|
#include "db/version_set.h" |
||||||
|
|
||||||
|
namespace rocksdb { |
||||||
|
|
||||||
|
class Version; |
||||||
|
|
||||||
|
// A Compaction encapsulates information about a compaction.
|
||||||
|
class Compaction { |
||||||
|
public: |
||||||
|
~Compaction(); |
||||||
|
|
||||||
|
// Return the level that is being compacted. Inputs from "level"
|
||||||
|
// will be merged.
|
||||||
|
int level() const { return level_; } |
||||||
|
|
||||||
|
// Outputs will go to this level
|
||||||
|
int output_level() const { return out_level_; } |
||||||
|
|
||||||
|
// Return the object that holds the edits to the descriptor done
|
||||||
|
// by this compaction.
|
||||||
|
VersionEdit* edit() { return edit_; } |
||||||
|
|
||||||
|
// "which" must be either 0 or 1
|
||||||
|
int num_input_files(int which) const { return inputs_[which].size(); } |
||||||
|
|
||||||
|
// Return the ith input file at "level()+which" ("which" must be 0 or 1).
|
||||||
|
FileMetaData* input(int which, int i) const { return inputs_[which][i]; } |
||||||
|
|
||||||
|
// Maximum size of files to build during this compaction.
|
||||||
|
uint64_t MaxOutputFileSize() const { return max_output_file_size_; } |
||||||
|
|
||||||
|
// Whether compression will be enabled for compaction outputs
|
||||||
|
bool enable_compression() const { return enable_compression_; } |
||||||
|
|
||||||
|
// Is this a trivial compaction that can be implemented by just
|
||||||
|
// moving a single input file to the next level (no merging or splitting)
|
||||||
|
bool IsTrivialMove() const; |
||||||
|
|
||||||
|
// Add all inputs to this compaction as delete operations to *edit.
|
||||||
|
void AddInputDeletions(VersionEdit* edit); |
||||||
|
|
||||||
|
// Returns true if the information we have available guarantees that
|
||||||
|
// the compaction is producing data in "level+1" for which no data exists
|
||||||
|
// in levels greater than "level+1".
|
||||||
|
bool IsBaseLevelForKey(const Slice& user_key); |
||||||
|
|
||||||
|
// Returns true iff we should stop building the current output
|
||||||
|
// before processing "internal_key".
|
||||||
|
bool ShouldStopBefore(const Slice& internal_key); |
||||||
|
|
||||||
|
// Release the input version for the compaction, once the compaction
|
||||||
|
// is successful.
|
||||||
|
void ReleaseInputs(); |
||||||
|
|
||||||
|
void Summary(char* output, int len); |
||||||
|
|
||||||
|
// Return the score that was used to pick this compaction run.
|
||||||
|
double score() const { return score_; } |
||||||
|
|
||||||
|
// Is this compaction creating a file in the bottom most level?
|
||||||
|
bool BottomMostLevel() { return bottommost_level_; } |
||||||
|
|
||||||
|
// Does this compaction include all sst files?
|
||||||
|
bool IsFullCompaction() { return is_full_compaction_; } |
||||||
|
|
||||||
|
private: |
||||||
|
friend class Version; |
||||||
|
friend class VersionSet; |
||||||
|
|
||||||
|
Compaction(Version* input_version, int level, int out_level, |
||||||
|
uint64_t target_file_size, uint64_t max_grandparent_overlap_bytes, |
||||||
|
bool seek_compaction = false, bool enable_compression = true); |
||||||
|
|
||||||
|
int level_; |
||||||
|
int out_level_; // levels to which output files are stored
|
||||||
|
uint64_t max_output_file_size_; |
||||||
|
uint64_t maxGrandParentOverlapBytes_; |
||||||
|
Version* input_version_; |
||||||
|
VersionEdit* edit_; |
||||||
|
int number_levels_; |
||||||
|
|
||||||
|
bool seek_compaction_; |
||||||
|
bool enable_compression_; |
||||||
|
|
||||||
|
// Each compaction reads inputs from "level_" and "level_+1"
|
||||||
|
std::vector<FileMetaData*> inputs_[2]; // The two sets of inputs
|
||||||
|
|
||||||
|
// State used to check for number of of overlapping grandparent files
|
||||||
|
// (parent == level_ + 1, grandparent == level_ + 2)
|
||||||
|
std::vector<FileMetaData*> grandparents_; |
||||||
|
size_t grandparent_index_; // Index in grandparent_starts_
|
||||||
|
bool seen_key_; // Some output key has been seen
|
||||||
|
uint64_t overlapped_bytes_; // Bytes of overlap between current output
|
||||||
|
// and grandparent files
|
||||||
|
int base_index_; // index of the file in files_[level_]
|
||||||
|
int parent_index_; // index of some file with same range in files_[level_+1]
|
||||||
|
double score_; // score that was used to pick this compaction.
|
||||||
|
|
||||||
|
// Is this compaction creating a file in the bottom most level?
|
||||||
|
bool bottommost_level_; |
||||||
|
// Does this compaction include all sst files?
|
||||||
|
bool is_full_compaction_; |
||||||
|
|
||||||
|
// level_ptrs_ holds indices into input_version_->levels_: our state
|
||||||
|
// is that we are positioned at one of the file ranges for each
|
||||||
|
// higher level than the ones involved in this compaction (i.e. for
|
||||||
|
// all L >= level_ + 2).
|
||||||
|
std::vector<size_t> level_ptrs_; |
||||||
|
|
||||||
|
// mark (or clear) all files that are being compacted
|
||||||
|
void MarkFilesBeingCompacted(bool); |
||||||
|
|
||||||
|
// Initialize whether compaction producing files at the bottommost level
|
||||||
|
void SetupBottomMostLevel(bool isManual); |
||||||
|
|
||||||
|
// In case of compaction error, reset the nextIndex that is used
|
||||||
|
// to pick up the next file to be compacted from files_by_size_
|
||||||
|
void ResetNextCompactionIndex(); |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace rocksdb
|
||||||
Loading…
Reference in new issue