VersionEdit類
主要是對Version的一些修改，比如add_files，new_files，還有log_number等。
VersionEdit一般只有一個。
Version類
Version類保存着有效的files。所以它的作用主要是進行files的Iterator的生成，生成key-range和overlaps。
需要注意的是level-0由於是有重疊的，所以是一個file一個iter，而level-0以上都是無重疊的，所以每個level都能返回一個twolevel-iter。
Version在每次進行Compact或者files_進行改動後就會新生成。
VersionSet::Builder類
主要有兩個函數Apply和SaveTo。前者是將VersionEdit的修改應用到VersionSet中，後者是將這些修改放入到一個Version中。
VersionSet類
主要由以下的職責：
1.Recovery。根據MANIFEST文件還原每個記錄的Version，然後記錄到VersionSet中。
2.LogAndApply。這個函數主要是當一個Version結束時，將這個Version所做的修改(VersionEdit裏)保存到一個新的Version中(VersionSet以後就使用這個Version了)，然後持久化到MANIFEST文件中(WriteSnapshot或者直接進行log record)。
3.PickCompaction。生成一個Compaction。
Compaction類。
由VersionSet的PickCompaction生成。主要記錄child和parent中參與compact的文件，並提供一些判斷操作。
另外Version中對Merge進行了以下的優化：
Version::PickLevelForMemTableOutput
儘量將文件放入到高層，但是又不能讓這層跟它的parent有太多的重疊。
Versioin::GetOverlappingInputs
在處理level-0時，採用感染的方法擴大compact的文件的範圍。因爲level-0的文件較小，compact的時候會相對快一些。使得對level-0的compact更爲徹底。這裏並沒有使用lazy的思想，反而是像打了一針興奮劑一樣，將level-0的處理提前了。eager的思想。
VersioinSet::PickCompaction
更傾向於使用size_compaction而不是seek_compaction。
將level-0中有重疊的部分都放入input[0]中
VersionSet::Finalize
對level-0使用文件個數策略，因爲它的file-size較小。對其它層使用文件大小策略。
VersionSet::SetupOtherInputs
在level和level+1的files選取上，有兩個考量：
1.爲了使level跟level+1結合到level+1的時候level+1不能有重合，需要得到level的samllest和largest在level+1中覆蓋的files。
2.當level+1的files確定以後，它可能會擴大這些files(levle和level+1)的range，在compact的size允許的情況下，可以反過來擴大level的file的範圍。這可以避免在以後的compaction中，level+1新形成的文件加入到這些file的compaction中來。
3.如果level的files擴展了，那麼它的key的range肯定也要擴展的，爲了保證1，必須重新計算level+1的files，源碼中當碰到這種情況時直接退出了，但是我覺得可以在2中加一個while循環。
Compaction::ShouldStopBefore
同Version::PickLevelForMemTableOutput一樣，這都是爲了避免跟上層有太多的重疊。
使用compact_pointer_的話，我們可能在size_compact中總是以第一個文件進行compact，這樣level+1層中的後半部分文件就不會得到同樣多的進行compact的機會。
附上versioin_set.cc的源碼及註釋：
// 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/version_set.h"
#include <algorithm>
#include <stdio.h>
#include "db/filename.h"
#include "db/log_reader.h"
#include "db/log_writer.h"
#include "db/memtable.h"
#include "db/table_cache.h"
#include "leveldb/env.h"
#include "leveldb/table_builder.h"
#include "table/merger.h"
#include "table/two_level_iterator.h"
#include "util/coding.h"
#include "util/logging.h"
namespace leveldb {
static const int kTargetFileSize = 2 * 1048576;
// Maximum bytes of overlaps in grandparent (i.e., level+2) before we
// stop building a single file in a level->level+1 compaction.
static const int64_t kMaxGrandParentOverlapBytes = 10 * kTargetFileSize;
// Maximum number of bytes in all compacted files. We avoid expanding
// the lower level file set of a compaction if it would make the
// total compaction cover more than this many bytes.
static const int64_t kExpandedCompactionByteSizeLimit = 25 * kTargetFileSize;
static double MaxBytesForLevel(int level) {
// Note: the result for level zero is not really used since we set
// the level-0 compaction threshold based on number of files.
double result = 10 * 1048576.0; // Result for both level-0 and level-1
while (level > 1) {
result *= 10;
level--;
}
return result;
}
static uint64_t MaxFileSizeForLevel(int level) {
return kTargetFileSize; // We could vary per level to reduce number of files?
}
static int64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
int64_t sum = 0;
for (size_t i = 0; i < files.size(); i++) {
sum += files[i]->file_size;
}
return sum;
}
namespace {
std::string IntSetToString(const std::set<uint64_t>& s) {
std::string result = "{";
for (std::set<uint64_t>::const_iterator it = s.begin();
it != s.end();
++it) {
result += (result.size() > 1) ? "," : "";
result += NumberToString(*it);
}
result += "}";
return result;
}
} // namespace
Version::~Version() {
assert(refs_ == 0);
// Remove from linked list
prev_->next_ = next_;
next_->prev_ = prev_;
// Drop references to files
for (int level = 0; level < config::kNumLevels; level++) {
for (size_t i = 0; i < files_[level].size(); i++) {
FileMetaData* f = files_[level][i];
assert(f->refs > 0);
f->refs--;
if (f->refs <= 0) {
delete f;
}
}
}
}
//在files中查找key，由於是二分查找，說明files中的key是有序的，查找到的是vector的index
//upper_bound
int FindFile(const InternalKeyComparator& icmp,
const std::vector<FileMetaData*>& files,
const Slice& key)
{
uint32_t left = 0;
uint32_t right = files.size();
while (left < right) {
uint32_t mid = (left + right) / 2;
const FileMetaData* f = files[mid];
if (icmp.InternalKeyComparator::Compare(f->largest.Encode(), key) < 0) {
// Key at "mid.largest" is < "target". Therefore all
// files at or before "mid" are uninteresting.
left = mid + 1;
} else {
// Key at "mid.largest" is >= "target". Therefore all files
// after "mid" are uninteresting.
right = mid;
}
}
return right;
}
//user_key是否比f的largest的user_key大
static bool AfterFile(const Comparator* ucmp,
const Slice* user_key, const FileMetaData* f)
{
// NULL user_key occurs before all keys and is therefore never after *f
//int r = ucmp->Compare(*user_key, f->largest.user_key());
return (user_key != NULL &&
ucmp->Compare(*user_key, f->largest.user_key()) > 0);
}
static bool BeforeFile(const Comparator* ucmp,
const Slice* user_key, const FileMetaData* f)
{
//int r = ucmp->Compare(*user_key, f->smallest.user_key());
// NULL user_key occurs after all keys and is therefore never before *f
return (user_key != NULL &&
ucmp->Compare(*user_key, f->smallest.user_key()) < 0);
}
//重疊：
//最小key比file的最小key還大，並且，最大key比file的最大key還小
bool SomeFileOverlapsRange(
const InternalKeyComparator& icmp,
bool disjoint_sorted_files,
const std::vector<FileMetaData*>& files,
const Slice* smallest_user_key,
const Slice* largest_user_key)
{
const Comparator* ucmp = icmp.user_comparator(); //非InternalKey比較
if (!disjoint_sorted_files) { //level0
// Need to check against all files
for (int i = 0; i < files.size(); i++) {
const FileMetaData* f = files[i];
if (AfterFile(ucmp, smallest_user_key, f) ||
BeforeFile(ucmp, largest_user_key, f)) {
// No overlap
} else {
return true; // Overlap
}
}
return false;
}
// Binary search over file list
uint32_t index = 0;
if (smallest_user_key != NULL) {
// Find the earliest possible internal key for smallest_user_key
InternalKey smalkeyl(*smallest_user_key, kMaxSequenceNumber,kValueTypeForSeek);
index = FindFile(icmp, files, smalkeyl.Encode());
}
if (index >= files.size()) {
// beginning of range is after all files, so no overlap.
return false;
}
return !BeforeFile(ucmp, largest_user_key, files[index]);
}
// An internal iterator. For a given version/level pair, yields
// information about the files in the level. For a given entry, key()
// is the largest key that occurs in the file, and value() is an
// 16-byte value containing the file number and file size, both
// encoded using EncodeFixed64.
class Version::LevelFileNumIterator : public Iterator {
public:
LevelFileNumIterator(const InternalKeyComparator& icmp,
const std::vector<FileMetaData*>* flist)
: icmp_(icmp),
flist_(flist),
index_(flist->size()) { // Marks as invalid
}
virtual bool Valid() const {
return index_ < flist_->size();
}
virtual void Seek(const Slice& target) {
index_ = FindFile(icmp_, *flist_, target);
}
virtual void SeekToFirst() { index_ = 0; }
virtual void SeekToLast() {
index_ = flist_->empty() ? 0 : flist_->size() - 1;
}
virtual void Next() {
assert(Valid());
index_++;
}
virtual void Prev() {
assert(Valid());
if (index_ == 0) {
index_ = flist_->size(); // Marks as invalid
} else {
index_--;
}
}
Slice key() const {
assert(Valid());
return (*flist_)[index_]->largest.Encode();
}
Slice value() const {
assert(Valid());
EncodeFixed64(value_buf_, (*flist_)[index_]->number);
EncodeFixed64(value_buf_+8, (*flist_)[index_]->file_size);
return Slice(value_buf_, sizeof(value_buf_));
}
virtual Status status() const { return Status::OK(); }
private:
const InternalKeyComparator icmp_;
const std::vector<FileMetaData*>* const flist_;
uint32_t index_;
// Backing store for value(). Holds the file number and size.
mutable char value_buf_[16];
};
static Iterator* GetFileIterator(void* arg,
const ReadOptions& options,
const Slice& file_value)
{
TableCache* cache = reinterpret_cast<TableCache*>(arg);
if (file_value.size() != 16) {
return NewErrorIterator(
Status::Corruption("FileReader invoked with unexpected value"));
} else {
return cache->NewIterator(options,
DecodeFixed64(file_value.data()), //file_num
DecodeFixed64(file_value.data() + 8)); //file_size
}
}
//連鎖，類似table的雙層迭代器
//外層迭代器爲level的迭代器
//內層迭代器爲file*
Iterator* Version::NewConcatenatingIterator(const ReadOptions& options,
int level) const
{
return NewTwoLevelIterator(
new LevelFileNumIterator(vset_->icmp_, &files_[level]),
&GetFileIterator, vset_->table_cache_, options);
}
//level0因爲有重疊，所以files的key不是有序的，但是每個file的key是有序的，所以需要添加多個iter
//0以上的files裏的key都是有序的，可以直接使用FindFile來查找，只需要一個iter
void Version::AddIterators(const ReadOptions& options,
std::vector<Iterator*>* iters)
{
// Merge all level zero files together since they may overlap
for (size_t i = 0; i < files_[0].size(); i++) {
iters->push_back(
vset_->table_cache_->NewIterator(
options, files_[0][i]->number, files_[0][i]->file_size));
}
// For levels > 0, we can use a concatenating iterator that sequentially
// walks through the non-overlapping files in the level, opening them
// lazily.
for (int level = 1; level < config::kNumLevels; level++) {
if (!files_[level].empty()) {
iters->push_back(NewConcatenatingIterator(options, level));
}
}
}
// If "*iter" points at a value or deletion for user_key, store
// either the value, or a NotFound error and return true.
// Else return false.
static bool GetValue(const Comparator* cmp,
Iterator* iter, const Slice& user_key,
std::string* value,
Status* s)
{
if (!iter->Valid()) {
return false;
}
ParsedInternalKey parsed_key;
if (!ParseInternalKey(iter->key(), &parsed_key)) {
*s = Status::Corruption("corrupted key for ", user_key);
return true;
}
if (cmp->Compare(parsed_key.user_key, user_key) != 0) {
return false;
}
switch (parsed_key.type) {
case kTypeDeletion:
*s = Status::NotFound(Slice()); // Use an empty error message for speed
break;
case kTypeValue: {
Slice v = iter->value();
value->assign(v.data(), v.size());
break;
}
}
return true;
}
static bool NewestFirst(FileMetaData* a, FileMetaData* b) {
return a->number > b->number;
}
//得到這個version中的key-value值
Status Version::Get(
const ReadOptions& options,
const LookupKey& k,
std::string* value,
GetStats* stats)
{
Slice ikey = k.internal_key();
Slice user_key = k.user_key();
const Comparator* ucmp = vset_->icmp_.user_comparator();
Status s;
stats->seek_file = NULL;
stats->seek_file_level = -1;
FileMetaData* last_file_read = NULL;
int last_file_read_level = -1;
// We can search level-by-level since entries never hop across
// levels. Therefore we are guaranteed that if we find data
// in an smaller level, later levels are irrelevant.
std::vector<FileMetaData*> tmp;
FileMetaData* tmp2;
//對於level-0是順序查找每個文件。對其它level是二分查找
for (int level = 0; level < config::kNumLevels; level++) {
size_t num_files = files_[level].size();
if (num_files == 0) continue;
// Get the list of files to search in this level
FileMetaData* const* files = &files_[level][0];
if (level == 0) {
// Level-0 files may overlap each other. Find all files that
// overlap user_key and process them in order from newest to oldest.
tmp.reserve(num_files);
for (uint32_t i = 0; i < num_files; i++) {
FileMetaData* f = files[i];
if (ucmp->Compare(user_key, f->smallest.user_key()) >= 0 &&
ucmp->Compare(user_key, f->largest.user_key()) <= 0) {
tmp.push_back(f);
}
}
if (tmp.empty()) continue;
//將file按照它們的number從大到小排列，因爲序號越大的file越新
std::sort(tmp.begin(), tmp.end(), NewestFirst);
files = &tmp[0];
num_files = tmp.size();
} else {
// Binary search to find earliest index whose largest key >= ikey.
uint32_t index = FindFile(vset_->icmp_, files_[level], ikey);
if (index >= num_files) {
files = NULL;
num_files = 0;
} else {
tmp2 = files[index];
if (ucmp->Compare(user_key, tmp2->smallest.user_key()) < 0) {
// All of "tmp2" is past any data for user_key
files = NULL;
num_files = 0;
} else {
files = &tmp2;
num_files = 1;
}
}
}
//從符合條件的文件中查找
for (uint32_t i = 0; i < num_files; ++i) {
if (last_file_read != NULL && stats->seek_file == NULL) {
// We have had more than one seek for this read. Charge the 1st file.
stats->seek_file = last_file_read;
stats->seek_file_level = last_file_read_level;
}
FileMetaData* f = files[i];
last_file_read = f;
last_file_read_level = level;
//這個iterator有可能是存在於cache中的。從cache中找並更新。
Iterator* iter = vset_->table_cache_->NewIterator(
options,
f->number,
f->file_size);
iter->Seek(ikey);
const bool done = GetValue(ucmp, iter, user_key, value, &s);
if (!iter->status().ok()) {
s = iter->status();
delete iter;
return s;
} else {
delete iter;
if (done) {
return s;
}
}
}
}
return Status::NotFound(Slice()); // Use an empty error message for speed{
}
bool Version::UpdateStats(const GetStats& stats) {
FileMetaData* f = stats.seek_file;
if (f != NULL) {
f->allowed_seeks--;
if (f->allowed_seeks <= 0 && file_to_compact_ == NULL) {
file_to_compact_ = f;
file_to_compact_level_ = stats.seek_file_level;
return true;
}
}
return false;
}
void Version::Ref() {
++refs_;
}
void Version::Unref() {
assert(this != &vset_->dummy_versions_);
assert(refs_ >= 1);
--refs_;
if (refs_ == 0) {
delete this;
}
}
bool Version::OverlapInLevel(int level,
const Slice* smallest_user_key,
const Slice* largest_user_key)
{
return SomeFileOverlapsRange(vset_->icmp_, (level > 0), files_[level],
smallest_user_key, largest_user_key);
}
//找到可以存放這個memtable的level
//這裏的原則是，儘量找到沒有重疊的最高level——這是第2個if的意思
//第3個if的意思是說，如果parent裏沒有重疊，level應該選取parent，
//但是如果兩層之間的重疊部分太多的話，下一次compact的概率就會增加
//但是如果在這兩層之間加一個“緩衝層”，則會減少compact的工作(畢竟層數越高，文件越大)
//這也是lazy思想的體現。
int Version::PickLevelForMemTableOutput(
const Slice& smallest_user_key,
const Slice& largest_user_key)
{
int level = 0;
// 如果1.level0裏有files的最大和最小key包含它(不一定是包含所有的key)
// 例如s = 0， l = 10， 那麼file的key可能爲，-1， 2， ，4， 9， 11，
// 也有可能爲：0， 1， 4， 9， 10，相同的key會在DoCompactWork的時候drop掉
if (!OverlapInLevel(0, &smallest_user_key, &largest_user_key)) {
// Push to next level if there is no overlap in next level,
// and the #bytes overlapping in the level after that are limited.
InternalKey start(smallest_user_key, kMaxSequenceNumber, kValueTypeForSeek);
InternalKey limit(largest_user_key, 0, static_cast<ValueType>(0));
std::vector<FileMetaData*> overlaps;
while (level < config::kMaxMemCompactLevel) {// level只能是0-kMaxMemCompactLevel(2)之間的數
if (OverlapInLevel(level + 1, &smallest_user_key, &largest_user_key)) {
// 或者2.它的parent裏有重疊
break;
}
GetOverlappingInputs(level + 2, &start, &limit, &overlaps);
const int64_t sum = TotalFileSize(overlaps);
if (sum > kMaxGrandParentOverlapBytes) {// 或者3.它的grandparent裏重疊數大於一定的值
break;
}
level++;
}
}
// 就返回這個level(不一定是0)
return level;
}
// Store in "*inputs" all files in "level" that overlap [begin,end]
//找到[begin,end]這一階段的file
//例如[40,100]。那麼file1[0,30],file2[31,50],file3[60,80],file4[90,110]中
//2，3，4都會加入
//並且，對於level0來說，由於其有覆蓋，這樣如果一個file只有一部分被包含在[begin,end]中
//就要擴大[begin,end]的範圍，這樣就會將所有重疊的files都加入到inputs中。
//這相當於感染，將所有level0中與這段區間有重疊的files都加入到inputs中。
//其實可以看到對level0的特殊處理只是發生在compact階段。
//這樣做感染處理以後，就會儘可能多地把有重疊的文件收集起來，而不是一次只對一小部分進行compact
//因爲level-0的文件較小，compact的時候會相對快一些。使得對level-0的compact更爲徹底。
//這裏並沒有使用lazy的思想，反而是像打了一針興奮劑一樣，將level-0的處理提前了。
void Version::GetOverlappingInputs(
int level,
const InternalKey* begin,
const InternalKey* end,
std::vector<FileMetaData*>* inputs)
{
inputs->clear();
Slice user_begin, user_end;
if (begin != NULL) {
user_begin = begin->user_key();
}
if (end != NULL) {
user_end = end->user_key();
}
const Comparator* user_cmp = vset_->icmp_.user_comparator();
for (size_t i = 0; i < files_[level].size(); ) {
FileMetaData* f = files_[level][i++];
const Slice file_start = f->smallest.user_key();
const Slice file_limit = f->largest.user_key();
if (begin != NULL && user_cmp->Compare(file_limit, user_begin) < 0) {
// "f" is completely before specified range; skip it
} else if (end != NULL && user_cmp->Compare(file_start, user_end) > 0) {
// "f" is completely after specified range; skip it
} else {
inputs->push_back(f);
if (level == 0) {//也就是說，找到Level0中所有的file的最小的smallest和最大的largest，取其中的file放入inputs
// Level-0 files may overlap each other. So check if the newly
// added file has expanded the range. If so, restart search.
if (begin != NULL && user_cmp->Compare(file_start, user_begin) < 0) {
user_begin = file_start;
inputs->clear();
i = 0;
} else if (end != NULL && user_cmp->Compare(file_limit, user_end) > 0) {
user_end = file_limit;
inputs->clear();
i = 0;
}
}
}
}
}
std::string Version::DebugString() const {
std::string r;
for (int level = 0; level < config::kNumLevels; level++) {
// E.g.,
// --- level 1 ---
// 17:123['a' .. 'd']
// 20:43['e' .. 'g']
r.append("--- level ");
AppendNumberTo(&r, level);
r.append(" ---\n");
const std::vector<FileMetaData*>& files = files_[level];
for (size_t i = 0; i < files.size(); i++) {
r.push_back(' ');
AppendNumberTo(&r, files[i]->number);
r.push_back(':');
AppendNumberTo(&r, files[i]->file_size);
r.append("[");
r.append(files[i]->smallest.DebugString());
r.append(" .. ");
r.append(files[i]->largest.DebugString());
r.append("]\n");
}
}
return r;
}
// A helper class so we can efficiently apply a whole sequence
// of edits to a particular state without creating intermediate
// Versions that contain full copies of the intermediate state.
class VersionSet::Builder {
private:
// Helper to sort by v->files_[file_number].smallest
struct BySmallestKey {
const InternalKeyComparator* internal_comparator;
//先比較key，再比較文件號
bool operator()(FileMetaData* f1, FileMetaData* f2) const {
int r = internal_comparator->Compare(f1->smallest, f2->smallest);
if (r != 0) {
return (r < 0);
} else {
// Break ties by file number
return (f1->number < f2->number);
}
}
};
typedef std::set<FileMetaData*, BySmallestKey> FileSet;
struct LevelState {
std::set<uint64_t> deleted_files;
FileSet* added_files;
};
VersionSet* vset_;
Version* base_;
LevelState levels_[config::kNumLevels];
public:
// Initialize a builder with the files from *base and other info from *vset
Builder(VersionSet* vset, Version* base)
: vset_(vset),
base_(base) {
base_->Ref();
BySmallestKey cmp;
cmp.internal_comparator = &vset_->icmp_;
for (int level = 0; level < config::kNumLevels; level++) {
levels_[level].added_files = new FileSet(cmp);
}
}
~Builder() {
for (int level = 0; level < config::kNumLevels; level++) {
const FileSet* added = levels_[level].added_files;
std::vector<FileMetaData*> to_unref;
to_unref.reserve(added->size());
for (FileSet::const_iterator it = added->begin();
it != added->end(); ++it) {
to_unref.push_back(*it);
}
delete added;
for (uint32_t i = 0; i < to_unref.size(); i++) {
FileMetaData* f = to_unref[i];
f->refs--;
if (f->refs <= 0) {
delete f;
}
}
}
base_->Unref();
}
// Apply all of the edits in *edit to the current state.
// 將edit中的信息應用到builder中，new_files應該是以前創建的sst文件
void Apply(VersionEdit* edit) {
// Update compaction pointers
for (size_t i = 0; i < edit->compact_pointers_.size(); i++) {
const int level = edit->compact_pointers_[i].first;
vset_->compact_pointer_[level] =
edit->compact_pointers_[i].second.Encode().ToString();
}
// Delete files
const VersionEdit::DeletedFileSet& del = edit->deleted_files_;
for (VersionEdit::DeletedFileSet::const_iterator iter = del.begin();
iter != del.end();
++iter) {
const int level = iter->first;
const uint64_t number = iter->second;
levels_[level].deleted_files.insert(number);
}
// Add new files
for (size_t i = 0; i < edit->new_files_.size(); i++) {
const int level = edit->new_files_[i].first;
FileMetaData* f = new FileMetaData(edit->new_files_[i].second);
f->refs = 1;
// We arrange to automatically compact this file after
// a certain number of seeks. Let's assume:
// (1) One seek costs 10ms
// (2) Writing or reading 1MB costs 10ms (100MB/s)
// (3) A compaction of 1MB does 25MB of IO:
// 1MB read from this level
// 10-12MB read from next level (boundaries may be misaligned)
// 10-12MB written to next level
// This implies that 25 seeks cost the same as the compaction
// of 1MB of data. I.e., one seek costs approximately the
// same as the compaction of 40KB of data. We are a little
// conservative and allow approximately one seek for every 16KB
// of data before triggering a compaction.
// 一個文件的seek次數是爲了避免這個文件長期滯留在低層帶來查找效率上的損失。
f->allowed_seeks = (f->file_size / 16384);
if (f->allowed_seeks < 100) f->allowed_seeks = 100;
levels_[level].deleted_files.erase(f->number);
levels_[level].added_files->insert(f);
}
}
// Save the current state in *v.
void SaveTo(Version* v) {
BySmallestKey cmp;
cmp.internal_comparator = &vset_->icmp_;
for (int level = 0; level < config::kNumLevels; level++) {
// Merge the set of added files with the set of pre-existing files.
// Drop any deleted files. Store the result in *v.
const std::vector<FileMetaData*>& base_files = base_->files_[level];
std::vector<FileMetaData*>::const_iterator base_iter = base_files.begin();
std::vector<FileMetaData*>::const_iterator base_end = base_files.end();
const FileSet* added = levels_[level].added_files;
v->files_[level].reserve(base_files.size() + added->size());
//將原來存在的files(base_files)和新增的files(added)按照大小的順序加入到files_中
//類似插入排序
//Merge,這個效率應該比較高一些(應該也不見得)
//OPTIMISZE ME:這個地方能不能寫成普通的merge?
for (FileSet::const_iterator added_iter = added->begin();
added_iter != added->end();
++added_iter) {
// Add all smaller files listed in base_
for (std::vector<FileMetaData*>::const_iterator bpos
= std::upper_bound(base_iter, base_end, *added_iter, cmp);
base_iter != bpos;
++base_iter) {
MaybeAddFile(v, level, *base_iter);
}
MaybeAddFile(v, level, *added_iter);
}
// Add remaining base files
for (; base_iter != base_end; ++base_iter) {
MaybeAddFile(v, level, *base_iter);
}
#ifndef NDEBUG
// Make sure there is no overlap in levels > 0
if (level > 0) {
for (uint32_t i = 1; i < v->files_[level].size(); i++) {
const InternalKey& prev_end = v->files_[level][i-1]->largest;
const InternalKey& this_begin = v->files_[level][i]->smallest;
if (vset_->icmp_.Compare(prev_end, this_begin) >= 0) {
fprintf(stderr, "overlapping ranges in same level %s vs. %s\n",
prev_end.DebugString().c_str(),
this_begin.DebugString().c_str());
abort();
}
}
}
#endif
}
}
void MaybeAddFile(Version* v, int level, FileMetaData* f) {
//因爲apply的時候是先delete再add的，在add的時候把重複的都刪去了，所以這個if不會運行到
if (levels_[level].deleted_files.count(f->number) > 0) {
// File is deleted: do nothing
} else {
std::vector<FileMetaData*>* files = &v->files_[level];
if (level > 0 && !files->empty()) {
// Must not overlap
assert(vset_->icmp_.Compare((*files)[files->size()-1]->largest,
f->smallest) < 0);
}
f->refs++;
files->push_back(f);
}
}
};
VersionSet::VersionSet(const std::string& dbname,
const Options* options,
TableCache* table_cache,
const InternalKeyComparator* cmp)
: env_(options->env),
dbname_(dbname),
options_(options),
table_cache_(table_cache),
icmp_(*cmp),
next_file_number_(2),
manifest_file_number_(0), // Filled by Recover()
last_sequence_(0),
log_number_(0),
prev_log_number_(0),
descriptor_file_(NULL),
descriptor_log_(NULL),
dummy_versions_(this),
current_(NULL)
{
AppendVersion(new Version(this));
}
VersionSet::~VersionSet() {
current_->Unref();
assert(dummy_versions_.next_ == &dummy_versions_); // List must be empty
delete descriptor_log_;
delete descriptor_file_;
}
//在LogAndApply和Recover中調用，
void VersionSet::AppendVersion(Version* v) {
// Make "v" current
assert(v->refs_ == 0);
assert(v != current_);
if (current_ != NULL) {
current_->Unref();
}
current_ = v;
v->Ref();
// Append to linked list
v->prev_ = dummy_versions_.prev_;
v->next_ = &dummy_versions_;
v->prev_->next_ = v;
v->next_->prev_ = v;
}
// 把edit的內容作爲一個record加入到manifest文件中，
// 並將當前version和edit結合起來新建一個version，然後加入到versions_中
Status VersionSet::LogAndApply(VersionEdit* edit, port::Mutex* mu) {
if (edit->has_log_number_) {
assert(edit->log_number_ >= log_number_);
assert(edit->log_number_ < next_file_number_);
} else {
edit->SetLogNumber(log_number_);
}
if (!edit->has_prev_log_number_) {
edit->SetPrevLogNumber(prev_log_number_);
}
edit->SetNextFile(next_file_number_);
edit->SetLastSequence(last_sequence_);
Version* v = new Version(this);
{
Builder builder(this, current_);
builder.Apply(edit);
builder.SaveTo(v);
}
Finalize(v);
// Initialize new descriptor log file if necessary by creating
// a temporary file that contains a snapshot of the current version.
std::string new_manifest_file;
Status s;
if (descriptor_log_ == NULL) {
// No reason to unlock *mu here since we only hit this path in the
// first call to LogAndApply (when opening the database).
assert(descriptor_file_ == NULL);
new_manifest_file = DescriptorFileName(dbname_, manifest_file_number_);
edit->SetNextFile(next_file_number_);
s = env_->NewWritableFile(new_manifest_file, &descriptor_file_);
if (s.ok()) {
descriptor_log_ = new log::Writer(descriptor_file_);
//這個函數添加了一個edit，有comparator，但是其它的爲false，因爲是新建。
s = WriteSnapshot(descriptor_log_);
}
}
// Unlock during expensive MANIFEST log write
{
mu->Unlock();
// Write new record to MANIFEST log
if (s.ok()) {
std::string record;
edit->EncodeTo(&record);
//現在又添加了一個edit，沒有comparator，但是其它的爲true
s = descriptor_log_->AddRecord(record);
if (s.ok()) {
s = descriptor_file_->Sync();
}
}
// If we just created a new descriptor file, install it by writing a
// new CURRENT file that points to it.
if (s.ok() && !new_manifest_file.empty()) {
s = SetCurrentFile(env_, dbname_, manifest_file_number_); //在CURRENT文件中記錄manifest文件的名字
}
mu->Lock();
}
// Install the new version
if (s.ok()) {
AppendVersion(v);
log_number_ = edit->log_number_;
prev_log_number_ = edit->prev_log_number_;
} else {
delete v;
if (!new_manifest_file.empty()) {
delete descriptor_log_;
delete descriptor_file_;
descriptor_log_ = NULL;
descriptor_file_ = NULL;
env_->DeleteFile(new_manifest_file);
}
}
return s;
}
//把以前的db的edit存儲到一個v中，這是本次db的第一個version，然後append到versions_中
Status VersionSet::Recover() {
struct LogReporter : public log::Reader::Reporter {
Status* status;
virtual void Corruption(size_t bytes, const Status& s) {
if (this->status->ok()) *this->status = s;
}
};
// Read "CURRENT" file, which contains a pointer to the current manifest file
std::string current;
Status s = ReadFileToString(env_, CurrentFileName(dbname_), ¤t);
if (!s.ok()) {
return s;
}
if (current.empty() || current[current.size()-1] != '\n') {
return Status::Corruption("CURRENT file does not end with newline");
}
//去掉\n
current.resize(current.size() - 1);
std::string dscname = dbname_ + "/" + current;
SequentialFile* file;
s = env_->NewSequentialFile(dscname, &file);
if (!s.ok()) {
return s;
}
// 以下的變量信息都是從manifest中獲得的
bool have_log_number = false;
bool have_prev_log_number = false;
bool have_next_file = false;
bool have_last_sequence = false;
uint64_t next_file = 0;
uint64_t last_sequence = 0;
uint64_t log_number = 0;
uint64_t prev_log_number = 0;
Builder builder(this, current_);
{//從CURRENT指示的manifest文件中讀取versionedit的信息
LogReporter reporter;
reporter.status = &s;
log::Reader reader(file, &reporter, true/*checksum*/, 0/*initial_offset*/);
Slice record;
std::string scratch;
while (reader.ReadRecord(&record, &scratch) && s.ok()) {
VersionEdit edit;
s = edit.DecodeFrom(record);
if (s.ok()) {
if (edit.has_comparator_ &&
edit.comparator_ != icmp_.user_comparator()->Name()) {
s = Status::InvalidArgument(
edit.comparator_ + "does not match existing comparator ",
icmp_.user_comparator()->Name());
}
}
if (s.ok()) {
// Apply中的levels_[level].added_files其實就是sst文件
builder.Apply(&edit);
}
// 更新變量信息
if (edit.has_log_number_) {
log_number = edit.log_number_;
have_log_number = true;
}
if (edit.has_prev_log_number_) {
prev_log_number = edit.prev_log_number_;
have_prev_log_number = true;
}
if (edit.has_next_file_number_) {
next_file = edit.next_file_number_;
have_next_file = true;
}
if (edit.has_last_sequence_) {
last_sequence = edit.last_sequence_;
have_last_sequence = true;
}
}
}
delete file;
file = NULL;
// 將next_file_number_更新至最高
if (s.ok()) {
if (!have_next_file) {
s = Status::Corruption("no meta-nextfile entry in descriptor");
} else if (!have_log_number) {
s = Status::Corruption("no meta-lognumber entry in descriptor");
} else if (!have_last_sequence) {
s = Status::Corruption("no last-sequence-number entry in descriptor");
}
if (!have_prev_log_number) {
prev_log_number = 0;
}
MarkFileNumberUsed(prev_log_number);
MarkFileNumberUsed(log_number);
}
// versions_中添加該version
if (s.ok()) {
Version* v = new Version(this);
builder.SaveTo(v);
// Install recovered version
Finalize(v);
AppendVersion(v);
manifest_file_number_ = next_file;
next_file_number_ = next_file + 1;
last_sequence_ = last_sequence;
log_number_ = log_number;
prev_log_number_ = prev_log_number;
}
return s;
}
void VersionSet::MarkFileNumberUsed(uint64_t number) {
if (next_file_number_ <= number) {
next_file_number_ = number + 1;
}
}
// 尋找這個version下一次compation時的最佳level和score
//OPTIMIZE ME:
//小文件對於leveldb來說並不是一件好事，因爲需要一層一層進行遍歷才能查找到一個key。
//所以這裏不能單純依靠size和nums來判斷，還需要對小文件做一些特別的處理
void VersionSet::Finalize(Version* v) {
// Precomputed best level for next compaction
int best_level = -1;
double best_score = -1;
for (int level = 0; level < config::kNumLevels-1; level++) {
double score;
if (level == 0) {
//主要還是因爲level-0的file_size太小了
// We treat level-0 specially by bounding the number of files
// instead of number of bytes for two reasons:
//
// (1) With larger write-buffer sizes, it is nice not to do too
// many level-0 compactions.
//
// (2) The files in level-0 are merged on every read and
// therefore we wish to avoid too many files when the individual
// file size is small (perhaps because of a small write-buffer
// setting, or very high compression ratios, or lots of
// overwrites/deletions).
score = v->files_[level].size() /
static_cast<double>(config::kL0_CompactionTrigger);
} else {
// Compute the ratio of current size to size limit.
const uint64_t level_bytes = TotalFileSize(v->files_[level]);
score = static_cast<double>(level_bytes) / MaxBytesForLevel(level);
}
if (score > best_score) {
best_level = level;
best_score = score;
}
}
v->compaction_level_ = best_level;
v->compaction_score_ = best_score;
}
//快照
Status VersionSet::WriteSnapshot(log::Writer* log) {
// TODO: Break up into multiple records to reduce memory usage on recovery?
// Save metadata
VersionEdit edit;
edit.SetComparatorName(icmp_.user_comparator()->Name());
// Save compaction pointers
for (int level = 0; level < config::kNumLevels; level++) {
if (!compact_pointer_[level].empty()) {
InternalKey key;
key.DecodeFrom(compact_pointer_[level]);
edit.SetCompactPointer(level, key);
}
}
// Save files
for (int level = 0; level < config::kNumLevels; level++) {
const std::vector<FileMetaData*>& files = current_->files_[level];
for (size_t i = 0; i < files.size(); i++) {
const FileMetaData* f = files[i];
edit.AddFile(level, f->number, f->file_size, f->smallest, f->largest);
}
}
std::string record;
edit.EncodeTo(&record);
return log->AddRecord(record);
}
int VersionSet::NumLevelFiles(int level) const {
assert(level >= 0);
assert(level < config::kNumLevels);
return current_->files_[level].size();
}
const char* VersionSet::LevelSummary(LevelSummaryStorage* scratch) const {
// Update code if kNumLevels changes
assert(config::kNumLevels == 7);
snprintf(scratch->buffer, sizeof(scratch->buffer),
"files[ %d %d %d %d %d %d %d ]",
int(current_->files_[0].size()),
int(current_->files_[1].size()),
int(current_->files_[2].size()),
int(current_->files_[3].size()),
int(current_->files_[4].size()),
int(current_->files_[5].size()),
int(current_->files_[6].size()));
return scratch->buffer;
}
//ikey以前的所有的file的大小。level-0要全部遍歷。其它level順序遍歷，然後break。
uint64_t VersionSet::ApproximateOffsetOf(Version* v, const InternalKey& ikey) {
uint64_t result = 0;
for (int level = 0; level < config::kNumLevels; level++) {
const std::vector<FileMetaData*>& files = v->files_[level];
for (size_t i = 0; i < files.size(); i++) {
if (icmp_.Compare(files[i]->largest, ikey) <= 0) {
// Entire file is before "ikey", so just add the file size
result += files[i]->file_size;
} else if (icmp_.Compare(files[i]->smallest, ikey) > 0) {
// Entire file is after "ikey", so ignore
if (level > 0) {
// Files other than level 0 are sorted by meta->smallest, so
// no further files in this level will contain data for
// "ikey".
break;
}
} else { //ikey處於文件的smallest和largest之間，計算ikey前面數據的大小
// "ikey" falls in the range for this table. Add the
// approximate offset of "ikey" within the table.
Table* tableptr;
Iterator* iter = table_cache_->NewIterator(
ReadOptions(), files[i]->number, files[i]->file_size, &tableptr);
if (tableptr != NULL) {
result += tableptr->ApproximateOffsetOf(ikey.Encode());
}
delete iter;
}
}
}
return result;
}
//把所有file的seqnumber加入到live中
void VersionSet::AddLiveFiles(std::set<uint64_t>* live) {
for (Version* v = dummy_versions_.next_;
v != &dummy_versions_;
v = v->next_) {
for (int level = 0; level < config::kNumLevels; level++) {
const std::vector<FileMetaData*>& files = v->files_[level];
for (size_t i = 0; i < files.size(); i++) {
live->insert(files[i]->number);
}
}
}
}
//當前version的file的大小
int64_t VersionSet::NumLevelBytes(int level) const {
assert(level >= 0);
assert(level < config::kNumLevels);
return TotalFileSize(current_->files_[level]);
}
//計算level裏所有files中與上層level具有最高重疊字節數的file在level+1中的重疊數
int64_t VersionSet::MaxNextLevelOverlappingBytes() {
int64_t result = 0;
std::vector<FileMetaData*> overlaps;
for (int level = 1; level < config::kNumLevels - 1; level++) {
for (size_t i = 0; i < current_->files_[level].size(); i++) {
const FileMetaData* f = current_->files_[level][i];
current_->GetOverlappingInputs(level+1, &f->smallest, &f->largest,
&overlaps);
const int64_t sum = TotalFileSize(overlaps);
if (sum > result) {
result = sum;
}
}
}
return result;
}
// Stores the minimal range that covers all entries in inputs in
// *smallest, *largest.
// REQUIRES: inputs is not empty
// 得到inputs中的最大最小key
void VersionSet::GetRange(const std::vector<FileMetaData*>& inputs,
InternalKey* smallest,
InternalKey* largest)
{
assert(!inputs.empty());
smallest->Clear();
largest->Clear();
for (size_t i = 0; i < inputs.size(); i++) {
FileMetaData* f = inputs[i];
if (i == 0) {
*smallest = f->smallest;
*largest = f->largest;
} else {
if (icmp_.Compare(f->smallest, *smallest) < 0) {
*smallest = f->smallest;
}
if (icmp_.Compare(f->largest, *largest) > 0) {
*largest = f->largest;
}
}
}
}
// Stores the minimal range that covers all entries in inputs1 and inputs2
// in *smallest, *largest.
// REQUIRES: inputs is not empty
void VersionSet::GetRange2(const std::vector<FileMetaData*>& inputs1,
const std::vector<FileMetaData*>& inputs2,
InternalKey* smallest,
InternalKey* largest)
{
std::vector<FileMetaData*> all = inputs1;
all.insert(all.end(), inputs2.begin(), inputs2.end());
GetRange(all, smallest, largest);
}
//將要進行Compaction的兩個level，每個level建一個iterator(level-0建立concate，其它的是twolevel)
//然後將這兩個iterator組合成merger iterator
Iterator* VersionSet::MakeInputIterator(Compaction* c) {
ReadOptions options;
options.verify_checksums = options_->paranoid_checks;
options.fill_cache = false;
// Level-0 files have to be merged together. For other levels,
// we will make a concatenating iterator per level.
// TODO(opt): use concatenating iterator for level-0 if there is no overlap
const int space = (c->level() == 0 ? c->inputs_[0].size() + 1/*level1 1個*/ : 2/*每個level一個*/);
Iterator** list = new Iterator*[space];
int num = 0;
for (int which = 0; which < 2; which++) {
if (!c->inputs_[which].empty()) {
if (c->level() + which == 0) {//level-0
const std::vector<FileMetaData*>& files = c->inputs_[which];
for (size_t i = 0; i < files.size(); i++) {
list[num++] = table_cache_->NewIterator(
options, files[i]->number, files[i]->file_size);
}
} else {
// Create concatenating iterator for the files from this level
// 兩個雙層迭代器。
list[num++] = NewTwoLevelIterator(
new Version::LevelFileNumIterator(icmp_, &c->inputs_[which]),
&GetFileIterator, table_cache_, options);
}
}
}
assert(num <= space);
Iterator* result = NewMergingIterator(&icmp_, list, num);
delete[] list;
return result;
}
//生成Compaction。
//1.根據是size還是seek類型創建一個compaction
//2.根據上一次更新的compact_pointer_[level]尋找第一個大於該key的file
//3.根據start和end在parent中找到覆蓋這段範圍的files
// 3.1 對level-0特殊對待。因爲level-0中的文件可能有重疊，那麼採用感染的方式將所有與該file
// 重疊的files全部加入到input_[0]中。
//4.設置input_[1]並優化input_[0](SetupOtherInputs).
Compaction* VersionSet::PickCompaction() {
Compaction* c;
int level;
// We prefer compactions triggered by too much data in a level over
// the compactions triggered by seeks.
// size_compaction是一個file，seek_compaction是file*
const bool size_compaction = (current_->compaction_score_ >= 1);
const bool seek_compaction = (current_->file_to_compact_ != NULL);
//size_compaction要優於seek_compaction
if (size_compaction) {
level = current_->compaction_level_;
assert(level >= 0);
assert(level+1 < config::kNumLevels);
c = new Compaction(level);
// Pick the first file that comes after compact_pointer_[level]
// 找到第一個largest_key比compact_pointer_[level]大的file
for (size_t i = 0; i < current_->files_[level].size(); i++) {
FileMetaData* f = current_->files_[level][i];
// 如果compact_pointer_[level]本來是空的，說明是第一次pick這個level的compaction
// 或者找到比上一次的compact_poiner_[level]還大的file加入到inputs_[0]中
if (compact_pointer_[level].empty() ||
//NOTE ME:
//注意這裏比較的是最大的key，而不是最小的key。
//因爲如果是level-0的話，key可能有重疊。第一個文件的最小key可能比key小，但是最大key比key要大。
icmp_.Compare(f->largest.Encode(), compact_pointer_[level]) > 0) {
c->inputs_[0].push_back(f);
break; //也就是說，input[0]裏現在只有一個文件
}
}
if (c->inputs_[0].empty()) {
// Wrap-around to the beginning of the key space
c->inputs_[0].push_back(current_->files_[level][0]);
}
} else if (seek_compaction) {
level = current_->file_to_compact_level_;
c = new Compaction(level);
c->inputs_[0].push_back(current_->file_to_compact_);
} else {
return NULL;
}
c->input_version_ = current_;
c->input_version_->Ref();
//input[0]這時只含有一個文件。所以leveldb的遷移並不是將所有的.sst遷移到高層。
//而是採用SetOtherInput的方法逐步擴大遷移的範圍，這樣就能達到levelTree的平衡。
// Files in level 0 may overlap each other, so pick up all overlapping ones
if (level == 0) {
InternalKey smallest, largest;
GetRange(c->inputs_[0], &smallest, &largest);
// Note that the next call will discard the file we placed in
// c->inputs_[0] earlier and replace it with an overlapping set
// which will include the picked file.
// 找到level0中其它的在smallest和largest之間的files加入到inputs_中
current_->GetOverlappingInputs(0, &smallest, &largest, &c->inputs_[0]);
assert(!c->inputs_[0].empty());
}
SetupOtherInputs(c);
return c;
}
//STAGE-GET&OPTIMISE:優化inputs_[0]和給inputs_[1]初始化。
//1.得到input_[0]中key的範圍smallest和largest
//2.根據這兩個key得到parents中這兩個key覆蓋的files
// (這是爲了保證parents中files沒有重疊。所以需要把這個區間的keys全部包含進來)
//3.由於parent的左右的兩個files很可能是開區間(也就是parent的key的range比child還大)，
// 根據0和1的files重新定義smallest和largest。
// (這是爲了簡化下一次compact時的工作。因爲如果parent與child有重疊的話，下次child進行compact的時候
// 會將這次compact生成的file包含進來，爲了避免以後做更多的compact工作，乾脆又重新擴大child的file的範圍)
//4.找到0和1的最大最小key。找到level中覆蓋這個區間的files加入到expand0
//5.如果expand0中的文件數大於input_[0]中的文件數，說明擴展了，重新定義key的區間，得到parent中的files加入expand1
//6.判斷expand1是否又擴展了input_[1]。如果不是這樣，才擴展。(這樣做的理由見註釋)
//STAGE-UPDATE:更新。
//1.根據重新定義的key範圍，尋找grandparent中覆蓋的files，這會在db_impl.cc中的ShoulStopBefore函數中用到
//2.更新這個level中下次Compact時開始的key:compact_pointer_[level]這會在PickCompaction尋找第一個file時用到
//OPTIMIZE ME:
//可能出現input[0]只有一個file，而且這個file的元素很少，但是它跨越了上一層的很多files
//這樣input[1]中會有很多的files，而進行compact的時候，基本上就是把input[1]的files進行了一下
//複製而已。有沒有可能優化一下？
//我覺得可以將這個文件同它的child進行compact，也就是說，當出現這樣的文件時，可以暫時不用管它，等它
//的child進行compact的時候自然這個文件就豐滿了。如果這個文件處在level-0，那麼一開始不去管它，
//等上層豐滿了之後，可以進行merge。也就是說，可以在計算expanded1後，
//判斷一下expanded1相對於input[1]增加了多少，如果增加得多，表示我們需要做一些無用功來複制文件
//也就是出現了“thin file”。對於這樣的文件應該記錄並加以向下處理或者延時處理。
//但是，在Compact::ShouldStopBefore函數中，當一個文件的key range與上層覆蓋太多時，會自動停止處理
//這樣，這一層就有可能出現小文件，我們需要記錄這個小文件，並對它進行處理。
//數據的存儲難免會出現一些類似拋物線的形狀，也就是說一些範圍的key出現得很少，但是他們的overlaps卻很大
//把這些文件成爲thin file。那麼merge就不僅要從高度上着手，而且也應該有寬度上的優化。
void VersionSet::SetupOtherInputs(Compaction* c) {
//STAGE-GET&OPTIMISE:
const int level = c->level();
InternalKey smallest, largest;
GetRange(c->inputs_[0], &smallest, &largest);
// 找到它的parents中在smallest和largest範圍的overlapps
current_->GetOverlappingInputs(level+1, &smallest, &largest, &c->inputs_[1]);
// Get entire range covered by compaction
// 找到level和level+1的smallest和largest，存入all_中，這個範圍必然不小於level對應的範圍
InternalKey all_start, all_limit;
//在上面GetOverlappingInputs後，level+1的files已經選取了出來。根據GetOverlappingInputs
//的操作，這個時候input[1]的files中最小key和最大key都可能已經擴大了input[0]key的範圍
//重新確定最大最小key的值。
//其實我覺得key的擴展只會發生在parent，而parent的level肯定大於0，不會有重疊，所以key的擴展
//只會發生在input_[1]的[0]和[size-1]文件中
GetRange2(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);
// See if we can grow the number of inputs in "level" without
// changing the number of "level+1" files we pick up.
if (!c->inputs_[1].empty()) {
std::vector<FileMetaData*> expanded0;
// level中在all_範圍內的files，必然不少於inputs_[0]的files
current_->GetOverlappingInputs(level, &all_start, &all_limit, &expanded0);
const int64_t inputs0_size = TotalFileSize(c->inputs_[0]);
const int64_t inputs1_size = TotalFileSize(c->inputs_[1]);
const int64_t expanded0_size = TotalFileSize(expanded0);
//OPTIMIZE ME:
//我覺得這裏可以是一個while循環，當第二個條件成立的時候就break，否則一直加入level中的file，直到達到limit
if (expanded0.size() > c->inputs_[0].size() && //level裏有inputs[0]中沒有包含的
inputs1_size + expanded0_size < kExpandedCompactionByteSizeLimit) {
//避免操作的數據太多，內存不夠，時間太長
//如果時間太長的話，這次的compaction沒有完，但是這層level又可以進行compaction了，
//此時level層下一次需要compact的file很可能與此次compact生成的file(當前正在生成)有重疊而不能進行compact
//但是這個地方有可能優化一下，就是看看這兩個file究竟有沒有重疊，或者compact其它的level。
//或者給這個version賦予另外一個versionset，等兩個compact完成之後再進行merge。
//但是這樣做的意義不大。
//
//然後找到level+1中在expand0範圍內的files
InternalKey new_start, new_limit;
GetRange(expanded0, &new_start, &new_limit);
std::vector<FileMetaData*> expanded1;
current_->GetOverlappingInputs(level+1, &new_start, &new_limit,
&expanded1);
//只有input_[1]沒有擴展，纔會擴展input_[0]。
//如果inout_[1]擴展了，那麼按照上面的邏輯，input_[0]又要擴展。input_[0]更擴展了又要擴展input_[1]...
//如此循環沒完沒了。所以乾脆只有在input[1]不變的時候才擴展input_[0]。
if (expanded1.size() == c->inputs_[1].size()) {
Log(options_->info_log,
"Expanding@%d %d+%d (%ld+%ld bytes) to %d+%d (%ld+%ld bytes)\n",
level,
int(c->inputs_[0].size()),
int(c->inputs_[1].size()),
long(inputs0_size), long(inputs1_size),
int(expanded0.size()),
int(expanded1.size()),
long(expanded0_size), long(inputs1_size));
smallest = new_start;
//largest只有在input_[1]的size沒有改變的時候才能更新，避免下次compact時遺漏這個file
largest = new_limit;
//擴展input_[0]和input_[1]
c->inputs_[0] = expanded0;
c->inputs_[1] = expanded1;
GetRange2(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);
}
}
}
// STAGE-UPDATE:開始更新
// 爲Compact::ShouldStopBefore提供grandparents_
// Compute the set of grandparent files that overlap this compaction
// (parent == level+1; grandparent == level+2)
// NOTE ME:
// 使用all_，因爲這是從parent的角度看grandparent
if (level + 2 < config::kNumLevels) {// 設置grandparent的files
current_->GetOverlappingInputs(level + 2, &all_start, &all_limit,
&c->grandparents_);
}
if (false) {
Log(options_->info_log, "Compacting %d '%s' .. '%s'",
level,
smallest.DebugString().c_str(),
largest.DebugString().c_str());
}
// Update the place where we will do the next compaction for this level.
// We update this immediately instead of waiting for the VersionEdit
// to be applied so that if the compaction fails, we will try a different
// key range next time.
// NOTE ME:
// 使用largest，因爲這是從level的角度看的，largest是根據level的range得到的。
compact_pointer_[level] = largest.Encode().ToString();
c->edit_.SetCompactPointer(level, largest);
}
// 類似於PickCompaction，但是只是在manual_compact的時候調用
Compaction* VersionSet::CompactRange(
int level,
const InternalKey* begin,
const InternalKey* end)
{
std::vector<FileMetaData*> inputs;
current_->GetOverlappingInputs(level, begin, end, &inputs);
if (inputs.empty()) {
return NULL;
}
// Avoid compacting too much in one shot in case the range is large.
const uint64_t limit = MaxFileSizeForLevel(level);
uint64_t total = 0;
for (int i = 0; i < inputs.size(); i++) {
uint64_t s = inputs[i]->file_size;
total += s;
if (total >= limit) {
inputs.resize(i + 1);
break;
}
}
Compaction* c = new Compaction(level);
c->input_version_ = current_;
c->input_version_->Ref();
c->inputs_[0] = inputs;
SetupOtherInputs(c);
return c;
}
Compaction::Compaction(int level)
: level_(level),
max_output_file_size_(MaxFileSizeForLevel(level)),
input_version_(NULL),
grandparent_index_(0),
seen_key_(false),
overlapped_bytes_(0)
{
for (int i = 0; i < config::kNumLevels; i++) {
level_ptrs_[i] = 0;
}
}
Compaction::~Compaction() {
if (input_version_ != NULL) {
input_version_->Unref();
}
}
// 如果level只有一個，level+1有0個，並且level+2的bytes小於限制，那麼將level中的file加入到level+1中
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.
return (num_input_files(0) == 1 &&
num_input_files(1) == 0 &&
TotalFileSize(grandparents_) <= kMaxGrandParentOverlapBytes);
}
//要刪除的sst文件
//將所有Compact的文件刪除。input[0]和input[1]中的文件都要刪除
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);
}
}
}
//只是簡單判斷一下這個key是否有能在高層overlap了。
//由de_impl.cc中的DoCompactionWork調用，來防止最新的(低層)delete信息丟失的情況。
bool Compaction::IsBaseLevelForKey(const Slice& user_key) {//這個level是這個key存在的最高level？
// Maybe use binary search to find right entry instead of linear search?
const Comparator* user_cmp = input_version_->vset_->icmp_.user_comparator();
// 如果user_key在lvl的file中，就返回false
// 現在正在compact lvl和lvl+1，所以從grandparent開始
// NOTE ME:
// level_ptrs_[lvl]一開始是0(在構造函數中被賦值)，後來在內層for循環中逐步淘汰被user_key超越的file
// 內層for循環的設計，比FindFile的二分查找還要高效。
for (int lvl = level_ + 2; lvl < config::kNumLevels; lvl++) {
const std::vector<FileMetaData*>& files = input_version_->files_[lvl];
for (; level_ptrs_[lvl] < files.size(); ) {
FileMetaData* f = files[level_ptrs_[lvl]];
// NOTE ME:
// 是先要比較最大的key
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;
}
//如果這個key落在f的範圍之外，那麼它後面的key(比它還要大)，更不可能落在這個key之內，牛逼。
//這個函數不是孤立的，它是由compact調用，每個key都要運行的。
level_ptrs_[lvl]++;
}
}
return true;
}
//判斷grandparent中覆蓋該key的文件的size。如果覆蓋太多，就停止這次的compact
//OPTIMIZE ME:
//首先，grandparent中所有的files的size加起來，也許不會達到kMaxGrandParentOverlapBytes
//其次，如果能夠超過，也可以一次性分好段，將compact的key劃分，這個函數可能是最浪費時間的了
//不過，我不知道我的推斷對不對。
//有可能導致小文件的出現，參看VersionSet::SetupOtherInputs的註釋
bool Compaction::ShouldStopBefore(const Slice& internal_key) {
// Scan to find earliest grandparent file that contains key.
const InternalKeyComparator* icmp = &input_version_->vset_->icmp_;
//OPTIMISE ME:
//由於grandparent的文件是從小到大排列的。而且DoCompactionWork在調用這個函數時
//也是已經建立了Iterator，那麼可以記錄上一個key覆蓋的大小。只有當grandparent_index_
//增加後才+=。
//grandparents_在確定下次compaction的start_key時更新。它是根據上次PickCompactionLevel
//時得到的最大最小key得到的level+2中overlap的files
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;
}
grandparent_index_++;
}
seen_key_ = true;
//因爲每層.sst文件的大小是固定的。如果超過了一定的bytes，也就是說這個Compaction即將形成的
//這個.sst文件(在level-n+1中)與level的grandparent(level-n+2)有太多的重疊，下一次Compact這個
//.sst文件時就會對太多的.sst文件進行操作。從而會將太多的數據放入內存，
//(這也應該是沒有根據.sst文件的數量而是根據重疊的size來計算的原因)
//因此要停止Compaction，可能是爲了減輕內存分配的負擔。
if (overlapped_bytes_ > kMaxGrandParentOverlapBytes) {
// Too much overlap for current output; start new output
// EXPLAIN ME:
// 總感覺這裏應該再添一個seen_key_ = false;
overlapped_bytes_ = 0;
return true;
} else {
return false;
}
}
void Compaction::ReleaseInputs() {
if (input_version_ != NULL) {
input_version_->Unref();
input_version_ = NULL;
}
}
} // namespace leveldb