2013-10-16 23:59:46 +02:00
|
|
|
// 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.
|
|
|
|
//
|
2011-03-18 23:37:00 +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.
|
|
|
|
//
|
|
|
|
// The representation of a DBImpl consists of a set of Versions. The
|
|
|
|
// newest version is called "current". Older versions may be kept
|
|
|
|
// around to provide a consistent view to live iterators.
|
|
|
|
//
|
|
|
|
// Each Version keeps track of a set of Table files per level. The
|
|
|
|
// entire set of versions is maintained in a VersionSet.
|
|
|
|
//
|
|
|
|
// Version,VersionSet are thread-compatible, but require external
|
|
|
|
// synchronization on all accesses.
|
|
|
|
|
2013-10-05 07:32:05 +02:00
|
|
|
#pragma once
|
2011-03-18 23:37:00 +01:00
|
|
|
#include <map>
|
2013-01-20 11:07:13 +01:00
|
|
|
#include <memory>
|
2011-03-18 23:37:00 +01:00
|
|
|
#include <set>
|
|
|
|
#include <vector>
|
2012-10-19 23:00:53 +02:00
|
|
|
#include <deque>
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "db/dbformat.h"
|
|
|
|
#include "db/version_edit.h"
|
|
|
|
#include "port/port.h"
|
2012-10-31 19:47:18 +01:00
|
|
|
#include "db/table_cache.h"
|
2014-01-16 01:22:34 +01:00
|
|
|
#include "db/compaction.h"
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
#include "db/compaction_picker.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2013-10-04 06:49:15 +02:00
|
|
|
namespace rocksdb {
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
namespace log { class Writer; }
|
|
|
|
|
|
|
|
class Compaction;
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
class CompactionPicker;
|
2011-03-18 23:37:00 +01:00
|
|
|
class Iterator;
|
|
|
|
class MemTable;
|
|
|
|
class TableCache;
|
|
|
|
class Version;
|
|
|
|
class VersionSet;
|
2013-12-03 03:34:05 +01:00
|
|
|
class MergeContext;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
// Return the smallest index i such that files[i]->largest >= key.
|
|
|
|
// Return files.size() if there is no such file.
|
|
|
|
// REQUIRES: "files" contains a sorted list of non-overlapping files.
|
|
|
|
extern int FindFile(const InternalKeyComparator& icmp,
|
|
|
|
const std::vector<FileMetaData*>& files,
|
|
|
|
const Slice& key);
|
|
|
|
|
2011-07-15 02:20:57 +02:00
|
|
|
// Returns true iff some file in "files" overlaps the user key range
|
2011-10-06 01:30:28 +02:00
|
|
|
// [*smallest,*largest].
|
2013-03-01 03:04:58 +01:00
|
|
|
// smallest==nullptr represents a key smaller than all keys in the DB.
|
|
|
|
// largest==nullptr represents a key largest than all keys in the DB.
|
2011-10-06 01:30:28 +02:00
|
|
|
// REQUIRES: If disjoint_sorted_files, files[] contains disjoint ranges
|
|
|
|
// in sorted order.
|
2011-06-22 04:36:45 +02:00
|
|
|
extern bool SomeFileOverlapsRange(
|
|
|
|
const InternalKeyComparator& icmp,
|
2011-10-06 01:30:28 +02:00
|
|
|
bool disjoint_sorted_files,
|
2011-06-22 04:36:45 +02:00
|
|
|
const std::vector<FileMetaData*>& files,
|
2011-10-06 01:30:28 +02:00
|
|
|
const Slice* smallest_user_key,
|
|
|
|
const Slice* largest_user_key);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
class Version {
|
|
|
|
public:
|
|
|
|
// Append to *iters a sequence of iterators that will
|
|
|
|
// yield the contents of this Version when merged together.
|
|
|
|
// REQUIRES: This version has been saved (see VersionSet::SaveTo)
|
2013-06-08 00:35:17 +02:00
|
|
|
void AddIterators(const ReadOptions&, const EnvOptions& soptions,
|
2013-03-15 01:00:04 +01:00
|
|
|
std::vector<Iterator*>* iters);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
// Lookup the value for key. If found, store it in *val and
|
|
|
|
// return OK. Else return a non-OK status. Fills *stats.
|
[RocksDB] [MergeOperator] The new Merge Interface! Uses merge sequences.
Summary:
Here are the major changes to the Merge Interface. It has been expanded
to handle cases where the MergeOperator is not associative. It does so by stacking
up merge operations while scanning through the key history (i.e.: during Get() or
Compaction), until a valid Put/Delete/end-of-history is encountered; it then
applies all of the merge operations in the correct sequence starting with the
base/sentinel value.
I have also introduced an "AssociativeMerge" function which allows the user to
take advantage of associative merge operations (such as in the case of counters).
The implementation will always attempt to merge the operations/operands themselves
together when they are encountered, and will resort to the "stacking" method if
and only if the "associative-merge" fails.
This implementation is conjectured to allow MergeOperator to handle the general
case, while still providing the user with the ability to take advantage of certain
efficiencies in their own merge-operator / data-structure.
NOTE: This is a preliminary diff. This must still go through a lot of review,
revision, and testing. Feedback welcome!
Test Plan:
-This is a preliminary diff. I have only just begun testing/debugging it.
-I will be testing this with the existing MergeOperator use-cases and unit-tests
(counters, string-append, and redis-lists)
-I will be "desk-checking" and walking through the code with the help gdb.
-I will find a way of stress-testing the new interface / implementation using
db_bench, db_test, merge_test, and/or db_stress.
-I will ensure that my tests cover all cases: Get-Memtable,
Get-Immutable-Memtable, Get-from-Disk, Iterator-Range-Scan, Flush-Memtable-to-L0,
Compaction-L0-L1, Compaction-Ln-L(n+1), Put/Delete found, Put/Delete not-found,
end-of-history, end-of-file, etc.
-A lot of feedback from the reviewers.
Reviewers: haobo, dhruba, zshao, emayanke
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11499
2013-08-06 05:14:32 +02:00
|
|
|
// Uses *operands to store merge_operator operations to apply later
|
2011-06-22 04:36:45 +02:00
|
|
|
// REQUIRES: lock is not held
|
|
|
|
struct GetStats {
|
|
|
|
FileMetaData* seek_file;
|
|
|
|
int seek_file_level;
|
|
|
|
};
|
2013-03-21 23:59:47 +01:00
|
|
|
void Get(const ReadOptions&, const LookupKey& key, std::string* val,
|
2013-12-03 03:34:05 +01:00
|
|
|
Status* status, MergeContext* merge_context,
|
2013-12-31 03:33:57 +01:00
|
|
|
GetStats* stats, const Options& db_option,
|
|
|
|
bool* value_found = nullptr);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
|
|
|
// Adds "stats" into the current state. Returns true if a new
|
|
|
|
// compaction may need to be triggered, false otherwise.
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
bool UpdateStats(const GetStats& stats);
|
|
|
|
|
2014-01-16 01:23:36 +01:00
|
|
|
// Updates internal structures that keep track of compaction scores
|
|
|
|
// We use compaction scores to figure out which compaction to do next
|
|
|
|
// Also pre-sorts level0 files for Get()
|
|
|
|
void Finalize(std::vector<uint64_t>& size_being_compacted);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Reference count management (so Versions do not disappear out from
|
|
|
|
// under live iterators)
|
|
|
|
void Ref();
|
2013-12-11 20:56:36 +01:00
|
|
|
// Decrease reference count. Delete the object if no reference left
|
|
|
|
// and return true. Otherwise, return false.
|
|
|
|
bool Unref();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2014-01-27 18:59:00 +01:00
|
|
|
// Returns true iff some level needs a compaction.
|
|
|
|
bool NeedsCompaction() const;
|
|
|
|
|
|
|
|
// Returns the maxmimum compaction score for levels 1 to max
|
|
|
|
double MaxCompactionScore() const { return max_compaction_score_; }
|
|
|
|
|
|
|
|
// See field declaration
|
|
|
|
int MaxCompactionScoreLevel() const { return max_compaction_score_level_; }
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
void GetOverlappingInputs(
|
|
|
|
int level,
|
2013-03-01 03:04:58 +01:00
|
|
|
const InternalKey* begin, // nullptr means before all keys
|
|
|
|
const InternalKey* end, // nullptr means after all keys
|
2012-11-06 18:06:16 +01:00
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int hint_index = -1, // index of overlap file
|
2013-03-01 03:04:58 +01:00
|
|
|
int* file_index = nullptr); // return index of overlap file
|
2011-10-06 01:30:28 +02:00
|
|
|
|
2012-11-05 08:47:06 +01:00
|
|
|
void GetOverlappingInputsBinarySearch(
|
|
|
|
int level,
|
2013-03-01 03:04:58 +01:00
|
|
|
const Slice& begin, // nullptr means before all keys
|
|
|
|
const Slice& end, // nullptr means after all keys
|
2012-11-06 18:06:16 +01:00
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int hint_index, // index of overlap file
|
|
|
|
int* file_index); // return index of overlap file
|
2012-11-05 08:47:06 +01:00
|
|
|
|
|
|
|
void ExtendOverlappingInputs(
|
|
|
|
int level,
|
2013-03-01 03:04:58 +01:00
|
|
|
const Slice& begin, // nullptr means before all keys
|
|
|
|
const Slice& end, // nullptr means after all keys
|
2012-11-05 08:47:06 +01:00
|
|
|
std::vector<FileMetaData*>* inputs,
|
2013-03-15 02:32:01 +01:00
|
|
|
unsigned int index); // start extending from this index
|
2012-11-05 08:47:06 +01:00
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
// Returns true iff some file in the specified level overlaps
|
2011-10-06 01:30:28 +02:00
|
|
|
// some part of [*smallest_user_key,*largest_user_key].
|
|
|
|
// smallest_user_key==NULL represents a key smaller than all keys in the DB.
|
|
|
|
// largest_user_key==NULL represents a key largest than all keys in the DB.
|
2011-06-22 04:36:45 +02:00
|
|
|
bool OverlapInLevel(int level,
|
2011-10-06 01:30:28 +02:00
|
|
|
const Slice* smallest_user_key,
|
|
|
|
const Slice* largest_user_key);
|
|
|
|
|
[RocksDB] [MergeOperator] The new Merge Interface! Uses merge sequences.
Summary:
Here are the major changes to the Merge Interface. It has been expanded
to handle cases where the MergeOperator is not associative. It does so by stacking
up merge operations while scanning through the key history (i.e.: during Get() or
Compaction), until a valid Put/Delete/end-of-history is encountered; it then
applies all of the merge operations in the correct sequence starting with the
base/sentinel value.
I have also introduced an "AssociativeMerge" function which allows the user to
take advantage of associative merge operations (such as in the case of counters).
The implementation will always attempt to merge the operations/operands themselves
together when they are encountered, and will resort to the "stacking" method if
and only if the "associative-merge" fails.
This implementation is conjectured to allow MergeOperator to handle the general
case, while still providing the user with the ability to take advantage of certain
efficiencies in their own merge-operator / data-structure.
NOTE: This is a preliminary diff. This must still go through a lot of review,
revision, and testing. Feedback welcome!
Test Plan:
-This is a preliminary diff. I have only just begun testing/debugging it.
-I will be testing this with the existing MergeOperator use-cases and unit-tests
(counters, string-append, and redis-lists)
-I will be "desk-checking" and walking through the code with the help gdb.
-I will find a way of stress-testing the new interface / implementation using
db_bench, db_test, merge_test, and/or db_stress.
-I will ensure that my tests cover all cases: Get-Memtable,
Get-Immutable-Memtable, Get-from-Disk, Iterator-Range-Scan, Flush-Memtable-to-L0,
Compaction-L0-L1, Compaction-Ln-L(n+1), Put/Delete found, Put/Delete not-found,
end-of-history, end-of-file, etc.
-A lot of feedback from the reviewers.
Reviewers: haobo, dhruba, zshao, emayanke
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11499
2013-08-06 05:14:32 +02:00
|
|
|
// Returns true iff the first or last file in inputs contains
|
|
|
|
// an overlapping user key to the file "just outside" of it (i.e.
|
|
|
|
// just after the last file, or just before the first file)
|
|
|
|
// REQUIRES: "*inputs" is a sorted list of non-overlapping files
|
|
|
|
bool HasOverlappingUserKey(const std::vector<FileMetaData*>* inputs,
|
|
|
|
int level);
|
|
|
|
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
// Return the level at which we should place a new memtable compaction
|
|
|
|
// result that covers the range [smallest_user_key,largest_user_key].
|
|
|
|
int PickLevelForMemTableOutput(const Slice& smallest_user_key,
|
|
|
|
const Slice& largest_user_key);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2014-01-16 01:15:43 +01:00
|
|
|
int NumberLevels() const { return num_levels_; }
|
|
|
|
|
|
|
|
// REQUIRES: lock is held
|
|
|
|
int NumLevelFiles(int level) const { return files_[level].size(); }
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2014-01-16 01:18:04 +01:00
|
|
|
// Return the combined file size of all files at the specified level.
|
|
|
|
int64_t NumLevelBytes(int level) const;
|
|
|
|
|
|
|
|
// Return a human-readable short (single-line) summary of the number
|
|
|
|
// of files per level. Uses *scratch as backing store.
|
|
|
|
struct LevelSummaryStorage {
|
|
|
|
char buffer[100];
|
|
|
|
};
|
|
|
|
struct FileSummaryStorage {
|
|
|
|
char buffer[1000];
|
|
|
|
};
|
|
|
|
const char* LevelSummary(LevelSummaryStorage* scratch) const;
|
|
|
|
// Return a human-readable short (single-line) summary of files
|
|
|
|
// in a specified level. Uses *scratch as backing store.
|
|
|
|
const char* LevelFileSummary(FileSummaryStorage* scratch, int level) const;
|
|
|
|
|
|
|
|
// Return the maximum overlapping data (in bytes) at next level for any
|
|
|
|
// file at a level >= 1.
|
|
|
|
int64_t MaxNextLevelOverlappingBytes();
|
|
|
|
|
|
|
|
// Add all files listed in the current version to *live.
|
|
|
|
void AddLiveFiles(std::set<uint64_t>* live);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Return a human readable string that describes this version's contents.
|
2012-12-16 03:28:36 +01:00
|
|
|
std::string DebugString(bool hex = false) const;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Returns the version nuber of this version
|
2014-01-16 01:18:04 +01:00
|
|
|
uint64_t GetVersionNumber() const { return version_number_; }
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2014-01-16 01:23:36 +01:00
|
|
|
// used to sort files by size
|
|
|
|
struct Fsize {
|
|
|
|
int index;
|
|
|
|
FileMetaData* file;
|
|
|
|
};
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
private:
|
|
|
|
friend class Compaction;
|
|
|
|
friend class VersionSet;
|
2013-06-30 08:21:36 +02:00
|
|
|
friend class DBImpl;
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
friend class CompactionPicker;
|
|
|
|
friend class LevelCompactionPicker;
|
|
|
|
friend class UniversalCompactionPicker;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
class LevelFileNumIterator;
|
2013-03-15 01:00:04 +01:00
|
|
|
Iterator* NewConcatenatingIterator(const ReadOptions&,
|
2013-06-08 00:35:17 +02:00
|
|
|
const EnvOptions& soptions,
|
2013-03-15 01:00:04 +01:00
|
|
|
int level) const;
|
2013-08-23 23:49:57 +02:00
|
|
|
bool PrefixMayMatch(const ReadOptions& options, const EnvOptions& soptions,
|
|
|
|
const Slice& internal_prefix, Iterator* level_iter) const;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2014-01-16 01:23:36 +01:00
|
|
|
// Sort all files for this version based on their file size and
|
|
|
|
// record results in files_by_size_. The largest files are listed first.
|
|
|
|
void UpdateFilesBySize();
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
VersionSet* vset_; // VersionSet to which this Version belongs
|
|
|
|
Version* next_; // Next version in linked list
|
2011-05-21 04:17:43 +02:00
|
|
|
Version* prev_; // Previous version in linked list
|
2011-03-18 23:37:00 +01:00
|
|
|
int refs_; // Number of live refs to this version
|
2014-01-16 01:15:43 +01:00
|
|
|
int num_levels_; // Number of levels
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-26 03:21:54 +02:00
|
|
|
// List of files per level, files in each level are arranged
|
|
|
|
// in increasing order of keys
|
2012-06-23 04:30:03 +02:00
|
|
|
std::vector<FileMetaData*>* files_;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-11-29 01:42:36 +01:00
|
|
|
// A list for the same set of files that are stored in files_,
|
|
|
|
// but files in each level are now sorted based on file
|
2012-10-26 03:21:54 +02:00
|
|
|
// size. The file with the largest size is at the front.
|
|
|
|
// This vector stores the index of the file from files_.
|
2013-12-31 03:33:57 +01:00
|
|
|
std::vector<std::vector<int>> files_by_size_;
|
2012-10-26 03:21:54 +02:00
|
|
|
|
2012-11-01 06:01:57 +01:00
|
|
|
// An index into files_by_size_ that specifies the first
|
|
|
|
// file that is not yet compacted
|
|
|
|
std::vector<int> next_file_to_compact_by_size_;
|
|
|
|
|
|
|
|
// Only the first few entries of files_by_size_ are sorted.
|
|
|
|
// There is no need to sort all the files because it is likely
|
|
|
|
// that on a running system, we need to look at only the first
|
|
|
|
// few largest files because a new version is created every few
|
|
|
|
// seconds/minutes (because of concurrent compactions).
|
|
|
|
static const int number_of_files_to_sort_ = 50;
|
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
// Next file to compact based on seek stats.
|
|
|
|
FileMetaData* file_to_compact_;
|
|
|
|
int file_to_compact_level_;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Level that should be compacted next and its compaction score.
|
|
|
|
// Score < 1 means compaction is not strictly needed. These fields
|
|
|
|
// are initialized by Finalize().
|
2012-10-19 23:00:53 +02:00
|
|
|
// The most critical level to be compacted is listed first
|
|
|
|
// These are used to pick the best compaction level
|
|
|
|
std::vector<double> compaction_score_;
|
|
|
|
std::vector<int> compaction_level_;
|
2012-10-29 22:18:00 +01:00
|
|
|
double max_compaction_score_; // max score in l1 to ln-1
|
2013-03-02 21:56:04 +01:00
|
|
|
int max_compaction_score_level_; // level on which max score occurs
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// A version number that uniquely represents this version. This is
|
|
|
|
// used for debugging and logging purposes only.
|
|
|
|
uint64_t version_number_;
|
|
|
|
|
|
|
|
explicit Version(VersionSet* vset, uint64_t version_number = 0);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
~Version();
|
|
|
|
|
2012-11-01 06:01:57 +01:00
|
|
|
// re-initializes the index that is used to offset into files_by_size_
|
|
|
|
// to find the next compaction candidate file.
|
|
|
|
void ResetNextCompactionIndex(int level) {
|
|
|
|
next_file_to_compact_by_size_[level] = 0;
|
2012-11-29 01:42:36 +01:00
|
|
|
}
|
2012-11-01 06:01:57 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// No copying allowed
|
|
|
|
Version(const Version&);
|
|
|
|
void operator=(const Version&);
|
|
|
|
};
|
|
|
|
|
|
|
|
class VersionSet {
|
|
|
|
public:
|
2014-01-16 01:18:04 +01:00
|
|
|
VersionSet(const std::string& dbname, const Options* options,
|
|
|
|
const EnvOptions& storage_options, TableCache* table_cache,
|
2011-03-18 23:37:00 +01:00
|
|
|
const InternalKeyComparator*);
|
|
|
|
~VersionSet();
|
|
|
|
|
|
|
|
// Apply *edit to the current version to form a new descriptor that
|
|
|
|
// is both saved to persistent state and installed as the new
|
2011-09-01 21:08:02 +02:00
|
|
|
// current version. Will release *mu while actually writing to the file.
|
|
|
|
// REQUIRES: *mu is held on entry.
|
|
|
|
// REQUIRES: no other thread concurrently calls LogAndApply()
|
2012-10-31 19:47:18 +01:00
|
|
|
Status LogAndApply(VersionEdit* edit, port::Mutex* mu,
|
2014-01-27 20:02:21 +01:00
|
|
|
Directory* db_directory = nullptr,
|
2014-01-16 01:15:43 +01:00
|
|
|
bool new_descriptor_log = false);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Recover the last saved descriptor from persistent storage.
|
2011-04-12 21:38:58 +02:00
|
|
|
Status Recover();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-31 19:47:18 +01:00
|
|
|
// Try to reduce the number of levels. This call is valid when
|
|
|
|
// only one level from the new max level to the old
|
|
|
|
// max level containing files.
|
Make VersionSet::ReduceNumberOfLevels() static
Summary:
A lot of our code implicitly assumes number_levels to be static. ReduceNumberOfLevels() breaks that assumption. For example, after calling ReduceNumberOfLevels(), DBImpl::NumberLevels() will be different from VersionSet::NumberLevels(). This is dangerous. Thankfully, it's not in public headers and is only used from LDB cmd tool. LDB tool is only using it statically, i.e. it never calls it with running DB instance. With this diff, we make it explicitly static. This way, we can assume number_levels to be immutable and not break assumption that lot of our code is relying upon. LDB tool can still use the method.
Also, I removed the method from a separate file since it breaks filename completition. version_se<TAB> now completes to "version_set." instead of "version_set" (without the dot). I don't see a big reason that the function should be in a different file.
Test Plan: reduce_levels_test
Reviewers: dhruba, haobo, kailiu, sdong
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15303
2014-01-24 23:57:04 +01:00
|
|
|
// The call is static, since number of levels is immutable during
|
|
|
|
// the lifetime of a RocksDB instance. It reduces number of levels
|
|
|
|
// in a DB by applying changes to manifest.
|
2012-10-31 19:47:18 +01:00
|
|
|
// For example, a db currently has 7 levels [0-6], and a call to
|
|
|
|
// to reduce to 5 [0-4] can only be executed when only one level
|
|
|
|
// among [4-6] contains files.
|
Make VersionSet::ReduceNumberOfLevels() static
Summary:
A lot of our code implicitly assumes number_levels to be static. ReduceNumberOfLevels() breaks that assumption. For example, after calling ReduceNumberOfLevels(), DBImpl::NumberLevels() will be different from VersionSet::NumberLevels(). This is dangerous. Thankfully, it's not in public headers and is only used from LDB cmd tool. LDB tool is only using it statically, i.e. it never calls it with running DB instance. With this diff, we make it explicitly static. This way, we can assume number_levels to be immutable and not break assumption that lot of our code is relying upon. LDB tool can still use the method.
Also, I removed the method from a separate file since it breaks filename completition. version_se<TAB> now completes to "version_set." instead of "version_set" (without the dot). I don't see a big reason that the function should be in a different file.
Test Plan: reduce_levels_test
Reviewers: dhruba, haobo, kailiu, sdong
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15303
2014-01-24 23:57:04 +01:00
|
|
|
static Status ReduceNumberOfLevels(const std::string& dbname,
|
|
|
|
const Options* options,
|
|
|
|
const EnvOptions& storage_options,
|
|
|
|
int new_levels);
|
2012-10-31 19:47:18 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Return the current version.
|
|
|
|
Version* current() const { return current_; }
|
|
|
|
|
2014-01-14 20:04:27 +01:00
|
|
|
// A Flag indicating whether write needs to slowdown because of there are
|
|
|
|
// too many number of level0 files.
|
|
|
|
bool NeedSlowdownForNumLevel0Files() const {
|
2014-01-16 01:18:04 +01:00
|
|
|
return need_slowdown_for_num_level0_files_;
|
2014-01-14 20:04:27 +01:00
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Return the current manifest file number
|
|
|
|
uint64_t ManifestFileNumber() const { return manifest_file_number_; }
|
|
|
|
|
|
|
|
// Allocate and return a new file number
|
|
|
|
uint64_t NewFileNumber() { return next_file_number_++; }
|
|
|
|
|
2012-08-27 08:45:35 +02:00
|
|
|
// Arrange to reuse "file_number" unless a newer file number has
|
|
|
|
// already been allocated.
|
|
|
|
// REQUIRES: "file_number" was returned by a call to NewFileNumber().
|
|
|
|
void ReuseFileNumber(uint64_t file_number) {
|
|
|
|
if (next_file_number_ == file_number + 1) {
|
|
|
|
next_file_number_ = file_number;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
// Return the last sequence number.
|
2013-12-20 18:57:58 +01:00
|
|
|
uint64_t LastSequence() const {
|
|
|
|
return last_sequence_.load(std::memory_order_acquire);
|
|
|
|
}
|
2011-04-12 21:38:58 +02:00
|
|
|
|
|
|
|
// Set the last sequence number to s.
|
|
|
|
void SetLastSequence(uint64_t s) {
|
|
|
|
assert(s >= last_sequence_);
|
2013-12-20 18:57:58 +01:00
|
|
|
last_sequence_.store(s, std::memory_order_release);
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
|
|
|
|
2011-09-01 21:08:02 +02:00
|
|
|
// Mark the specified file number as used.
|
|
|
|
void MarkFileNumberUsed(uint64_t number);
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
// Return the current log file number.
|
|
|
|
uint64_t LogNumber() const { return log_number_; }
|
|
|
|
|
|
|
|
// Return the log file number for the log file that is currently
|
|
|
|
// being compacted, or zero if there is no such log file.
|
|
|
|
uint64_t PrevLogNumber() const { return prev_log_number_; }
|
|
|
|
|
2012-10-31 19:47:18 +01:00
|
|
|
int NumberLevels() const { return num_levels_; }
|
2012-06-23 04:30:03 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Pick level and inputs for a new compaction.
|
2013-03-01 03:04:58 +01:00
|
|
|
// Returns nullptr if there is no compaction to be done.
|
2011-03-18 23:37:00 +01:00
|
|
|
// Otherwise returns a pointer to a heap-allocated object that
|
|
|
|
// describes the compaction. Caller should delete the result.
|
|
|
|
Compaction* PickCompaction();
|
|
|
|
|
|
|
|
// Return a compaction object for compacting the range [begin,end] in
|
2013-03-01 03:04:58 +01:00
|
|
|
// the specified level. Returns nullptr if there is nothing in that
|
2011-03-18 23:37:00 +01:00
|
|
|
// level that overlaps the specified range. Caller should delete
|
|
|
|
// the result.
|
2014-01-15 01:19:09 +01:00
|
|
|
//
|
|
|
|
// The returned Compaction might not include the whole requested range.
|
|
|
|
// In that case, compaction_end will be set to the next key that needs
|
|
|
|
// compacting. In case the compaction will compact the whole range,
|
|
|
|
// compaction_end will be set to nullptr.
|
|
|
|
// Client is responsible for compaction_end storage -- when called,
|
|
|
|
// *compaction_end should point to valid InternalKey!
|
|
|
|
Compaction* CompactRange(int input_level,
|
|
|
|
int output_level,
|
|
|
|
const InternalKey* begin,
|
|
|
|
const InternalKey* end,
|
|
|
|
InternalKey** compaction_end);
|
2011-03-22 19:32:49 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Create an iterator that reads over the compaction inputs for "*c".
|
|
|
|
// The caller should delete the iterator when no longer needed.
|
|
|
|
Iterator* MakeInputIterator(Compaction* c);
|
|
|
|
|
|
|
|
// Add all files listed in any live version to *live.
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
void AddLiveFiles(std::vector<uint64_t>* live_list);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Return the approximate offset in the database of the data for
|
|
|
|
// "key" as of version "v".
|
|
|
|
uint64_t ApproximateOffsetOf(Version* v, const InternalKey& key);
|
|
|
|
|
2012-08-17 19:48:40 +02:00
|
|
|
// printf contents (for debugging)
|
2012-11-19 20:54:13 +01:00
|
|
|
Status DumpManifest(Options& options, std::string& manifestFileName,
|
2012-12-16 03:28:36 +01:00
|
|
|
bool verbose, bool hex = false);
|
2012-08-17 19:48:40 +02:00
|
|
|
|
2012-09-24 23:01:01 +02:00
|
|
|
// Return the size of the current manifest file
|
2014-01-16 01:15:43 +01:00
|
|
|
uint64_t ManifestFileSize() const { return manifest_file_size_; }
|
2012-09-24 23:01:01 +02:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// verify that the files that we started with for a compaction
|
|
|
|
// 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.
|
|
|
|
bool VerifyCompactionFileConsistency(Compaction* c);
|
|
|
|
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
double MaxBytesForLevel(int level);
|
|
|
|
|
2013-01-15 23:05:42 +01:00
|
|
|
// Get the max file size in a given level.
|
|
|
|
uint64_t MaxFileSizeForLevel(int level);
|
|
|
|
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
void ReleaseCompactionFiles(Compaction* c, Status status);
|
2013-05-31 07:57:22 +02:00
|
|
|
|
2013-08-22 23:32:53 +02:00
|
|
|
Status GetMetadataForFile(
|
2014-01-07 05:29:17 +01:00
|
|
|
uint64_t number, int *filelevel, FileMetaData **metadata);
|
2013-08-22 23:32:53 +02:00
|
|
|
|
|
|
|
void GetLiveFilesMetaData(
|
|
|
|
std::vector<LiveFileMetaData> *metadata);
|
|
|
|
|
2013-11-12 20:53:26 +01:00
|
|
|
void GetObsoleteFiles(std::vector<FileMetaData*>* files);
|
2013-11-09 00:23:46 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
private:
|
|
|
|
class Builder;
|
2012-10-19 23:00:53 +02:00
|
|
|
struct ManifestWriter;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
friend class Compaction;
|
|
|
|
friend class Version;
|
|
|
|
|
2011-09-01 21:08:02 +02:00
|
|
|
// Save current contents to *log
|
|
|
|
Status WriteSnapshot(log::Writer* log);
|
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
void AppendVersion(Version* v);
|
|
|
|
|
2013-01-08 21:00:13 +01:00
|
|
|
bool ManifestContains(const std::string& record) const;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Env* const env_;
|
|
|
|
const std::string dbname_;
|
|
|
|
const Options* const options_;
|
|
|
|
TableCache* const table_cache_;
|
|
|
|
const InternalKeyComparator icmp_;
|
|
|
|
uint64_t next_file_number_;
|
|
|
|
uint64_t manifest_file_number_;
|
2013-12-20 18:57:58 +01:00
|
|
|
std::atomic<uint64_t> last_sequence_;
|
2011-04-12 21:38:58 +02:00
|
|
|
uint64_t log_number_;
|
|
|
|
uint64_t prev_log_number_; // 0 or backing store for memtable being compacted
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-31 19:47:18 +01:00
|
|
|
int num_levels_;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Opened lazily
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<log::Writer> descriptor_log_;
|
2011-05-21 04:17:43 +02:00
|
|
|
Version dummy_versions_; // Head of circular doubly-linked list of versions.
|
|
|
|
Version* current_; // == dummy_versions_.prev_
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2014-01-16 01:18:04 +01:00
|
|
|
// A flag indicating whether we should delay writes because
|
|
|
|
// we have too many level 0 files
|
|
|
|
bool need_slowdown_for_num_level0_files_;
|
2014-01-14 20:04:27 +01:00
|
|
|
|
CompactionPicker
Summary:
This is a big one. This diff moves all the code related to picking compactions from VersionSet to new class CompactionPicker. Column families' compactions will be completely separate processes, so we need to have multiple CompactionPickers.
To make this easier to review, most of the code change is just copy/paste. There is also a small change not to use VersionSet::current_, but rather to take `Version* version` as a parameter. Most of the other code is exactly the same.
In future diffs, I will also make some improvements to CompactionPickers. I think the most important part will be encapsulating it better. Currently Version, VersionSet, Compaction and CompactionPicker are all friend classes, which makes it harder to change the implementation.
This diff depends on D15171, D15183, D15189 and D15201
Test Plan: `make check`
Reviewers: kailiu, sdong, dhruba, haobo
Reviewed By: kailiu
CC: leveldb
Differential Revision: https://reviews.facebook.net/D15207
2014-01-16 22:03:52 +01:00
|
|
|
// An object that keeps all the compaction stats
|
|
|
|
// and picks the next compaction
|
|
|
|
std::unique_ptr<CompactionPicker> compaction_picker_;
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
// generates a increasing version number for every new version
|
|
|
|
uint64_t current_version_number_;
|
|
|
|
|
|
|
|
// Queue of writers to the manifest file
|
|
|
|
std::deque<ManifestWriter*> manifest_writers_;
|
|
|
|
|
2014-01-16 01:15:43 +01:00
|
|
|
// Current size of manifest file
|
|
|
|
uint64_t manifest_file_size_;
|
2013-01-11 02:18:50 +01:00
|
|
|
|
2013-11-09 00:23:46 +01:00
|
|
|
std::vector<FileMetaData*> obsolete_files_;
|
|
|
|
|
2013-03-15 01:00:04 +01:00
|
|
|
// storage options for all reads and writes except compactions
|
2013-06-08 00:35:17 +02:00
|
|
|
const EnvOptions& storage_options_;
|
2013-03-15 01:00:04 +01:00
|
|
|
|
|
|
|
// storage options used for compactions. This is a copy of
|
|
|
|
// storage_options_ but with readaheads set to readahead_compactions_.
|
2013-06-08 00:35:17 +02:00
|
|
|
const EnvOptions storage_options_compactions_;
|
2013-03-15 01:00:04 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// No copying allowed
|
|
|
|
VersionSet(const VersionSet&);
|
|
|
|
void operator=(const VersionSet&);
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
void LogAndApplyHelper(Builder*b, Version* v,
|
|
|
|
VersionEdit* edit, port::Mutex* mu);
|
2011-03-18 23:37:00 +01:00
|
|
|
};
|
|
|
|
|
2013-10-04 06:49:15 +02:00
|
|
|
} // namespace rocksdb
|