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.
|
|
|
|
|
|
|
|
#ifndef STORAGE_LEVELDB_DB_VERSION_SET_H_
|
|
|
|
#define STORAGE_LEVELDB_DB_VERSION_SET_H_
|
|
|
|
|
|
|
|
#include <map>
|
|
|
|
#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"
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
namespace leveldb {
|
|
|
|
|
|
|
|
namespace log { class Writer; }
|
|
|
|
|
|
|
|
class Compaction;
|
|
|
|
class Iterator;
|
|
|
|
class MemTable;
|
|
|
|
class TableBuilder;
|
|
|
|
class TableCache;
|
|
|
|
class Version;
|
|
|
|
class VersionSet;
|
|
|
|
class WritableFile;
|
|
|
|
|
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].
|
|
|
|
// smallest==NULL represents a key smaller than all keys in the DB.
|
|
|
|
// largest==NULL represents a key largest than all keys in the DB.
|
|
|
|
// 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)
|
|
|
|
void AddIterators(const ReadOptions&, std::vector<Iterator*>* iters);
|
|
|
|
|
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.
|
|
|
|
// REQUIRES: lock is not held
|
|
|
|
struct GetStats {
|
|
|
|
FileMetaData* seek_file;
|
|
|
|
int seek_file_level;
|
|
|
|
};
|
|
|
|
Status Get(const ReadOptions&, const LookupKey& key, std::string* val,
|
|
|
|
GetStats* stats);
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Reference count management (so Versions do not disappear out from
|
|
|
|
// under live iterators)
|
|
|
|
void Ref();
|
|
|
|
void Unref();
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
void GetOverlappingInputs(
|
|
|
|
int level,
|
|
|
|
const InternalKey* begin, // NULL means before all keys
|
|
|
|
const InternalKey* end, // NULL means after all keys
|
2012-11-06 18:06:16 +01:00
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int hint_index = -1, // index of overlap file
|
|
|
|
int* file_index = NULL); // 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,
|
|
|
|
const Slice& begin, // NULL means before all keys
|
|
|
|
const Slice& end, // NULL 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,
|
|
|
|
const Slice& begin, // NULL means before all keys
|
|
|
|
const Slice& end, // NULL means after all keys
|
|
|
|
std::vector<FileMetaData*>* inputs,
|
|
|
|
int index); // start extending from this index
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
// 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
|
|
|
|
|
|
|
int NumFiles(int level) const { return files_[level].size(); }
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Return a human readable string that describes this version's contents.
|
|
|
|
std::string DebugString() const;
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Returns the version nuber of this version
|
|
|
|
uint64_t GetVersionNumber() {
|
|
|
|
return version_number_;
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
private:
|
|
|
|
friend class Compaction;
|
|
|
|
friend class VersionSet;
|
|
|
|
|
|
|
|
class LevelFileNumIterator;
|
|
|
|
Iterator* NewConcatenatingIterator(const ReadOptions&, int level) const;
|
|
|
|
|
|
|
|
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
|
|
|
|
|
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-10-26 03:21:54 +02: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
|
|
|
|
// size. The file with the largest size is at the front.
|
|
|
|
// This vector stores the index of the file from files_.
|
|
|
|
std::vector< std::vector<int> > files_by_size_;
|
|
|
|
|
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
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-09-24 23:01:01 +02:00
|
|
|
// The offset in the manifest file where this version is stored.
|
|
|
|
uint64_t offset_manifest_file_;
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// No copying allowed
|
|
|
|
Version(const Version&);
|
|
|
|
void operator=(const Version&);
|
|
|
|
};
|
|
|
|
|
|
|
|
class VersionSet {
|
|
|
|
public:
|
|
|
|
VersionSet(const std::string& dbname,
|
|
|
|
const Options* options,
|
|
|
|
TableCache* table_cache,
|
|
|
|
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,
|
|
|
|
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.
|
|
|
|
// 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.
|
|
|
|
Status ReduceNumberOfLevels(int new_levels, port::Mutex* mu);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Return the current version.
|
|
|
|
Version* current() const { return current_; }
|
|
|
|
|
|
|
|
// 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-03-18 23:37:00 +01:00
|
|
|
// Return the number of Table files at the specified level.
|
|
|
|
int NumLevelFiles(int level) const;
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
// Return the combined file size of all files at the specified level.
|
|
|
|
int64_t NumLevelBytes(int level) const;
|
|
|
|
|
|
|
|
// Return the last sequence number.
|
|
|
|
uint64_t LastSequence() const { return last_sequence_; }
|
|
|
|
|
|
|
|
// Set the last sequence number to s.
|
|
|
|
void SetLastSequence(uint64_t s) {
|
|
|
|
assert(s >= last_sequence_);
|
|
|
|
last_sequence_ = s;
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
// Returns NULL if there is no compaction to be done.
|
|
|
|
// 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
|
|
|
|
// the specified level. Returns NULL if there is nothing in that
|
|
|
|
// level that overlaps the specified range. Caller should delete
|
|
|
|
// the result.
|
|
|
|
Compaction* CompactRange(
|
|
|
|
int level,
|
2011-10-06 01:30:28 +02:00
|
|
|
const InternalKey* begin,
|
|
|
|
const InternalKey* end);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-03-22 19:32:49 +01:00
|
|
|
// Return the maximum overlapping data (in bytes) at next level for any
|
|
|
|
// file at a level >= 1.
|
2011-03-23 00:24:02 +01:00
|
|
|
int64_t MaxNextLevelOverlappingBytes();
|
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);
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Returns true iff some level needs a compaction because it has
|
|
|
|
// exceeded its target size.
|
|
|
|
bool NeedsSizeCompaction() const {
|
|
|
|
for (int i = 0; i < NumberLevels()-1; i++) {
|
|
|
|
if (current_->compaction_score_[i] >= 1) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
// Returns true iff some level needs a compaction.
|
2011-06-22 04:36:45 +02:00
|
|
|
bool NeedsCompaction() const {
|
2012-10-19 23:00:53 +02:00
|
|
|
return ((current_->file_to_compact_ != NULL) ||
|
|
|
|
NeedsSizeCompaction());
|
2011-06-22 04:36:45 +02:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-26 22:37:21 +02:00
|
|
|
// Returns the maxmimum compaction score for levels 1 to max
|
|
|
|
double MaxCompactionScore() const {
|
2012-10-29 22:18:00 +01:00
|
|
|
return current_->max_compaction_score_;
|
2012-10-26 22:37:21 +02:00
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Add all files listed in any live version to *live.
|
|
|
|
// May also mutate some internal state.
|
|
|
|
void AddLiveFiles(std::set<uint64_t>* live);
|
|
|
|
|
2012-09-15 02:11:35 +02:00
|
|
|
// Add all files listed in the current version to *live.
|
|
|
|
void AddLiveFilesCurrentVersion(std::set<uint64_t>* live);
|
|
|
|
|
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);
|
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
// 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];
|
|
|
|
};
|
|
|
|
const char* LevelSummary(LevelSummaryStorage* scratch) const;
|
|
|
|
|
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,
|
|
|
|
bool verbose);
|
2012-08-17 19:48:40 +02:00
|
|
|
|
2012-08-15 00:20:36 +02:00
|
|
|
// Return a human-readable short (single-line) summary of the data size
|
|
|
|
// of files per level. Uses *scratch as backing store.
|
|
|
|
const char* LevelDataSizeSummary(LevelSummaryStorage* scratch) const;
|
|
|
|
|
2012-09-24 23:01:01 +02:00
|
|
|
// Return the size of the current manifest file
|
|
|
|
const uint64_t ManifestFileSize() { return current_->offset_manifest_file_; }
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// For the specfied level, pick a compaction.
|
|
|
|
// Returns NULL if there is no compaction to be done.
|
|
|
|
Compaction* PickCompactionBySize(int level);
|
|
|
|
|
|
|
|
// Free up the files that were participated in a compaction
|
2012-11-01 06:01:57 +01:00
|
|
|
void ReleaseCompactionFiles(Compaction* c, Status status);
|
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);
|
|
|
|
|
2012-11-01 06:01:57 +01:00
|
|
|
// used to sort files by size
|
|
|
|
typedef struct fsize {
|
|
|
|
int index;
|
|
|
|
FileMetaData* file;
|
|
|
|
} Fsize;
|
|
|
|
|
|
|
|
// 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(Version *v);
|
|
|
|
|
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;
|
|
|
|
|
2012-10-31 19:47:18 +01:00
|
|
|
void Init(int num_levels);
|
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
void Finalize(Version* v);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
void GetRange(const std::vector<FileMetaData*>& inputs,
|
|
|
|
InternalKey* smallest,
|
|
|
|
InternalKey* largest);
|
|
|
|
|
2011-03-22 19:32:49 +01:00
|
|
|
void GetRange2(const std::vector<FileMetaData*>& inputs1,
|
|
|
|
const std::vector<FileMetaData*>& inputs2,
|
|
|
|
InternalKey* smallest,
|
|
|
|
InternalKey* largest);
|
|
|
|
|
|
|
|
void SetupOtherInputs(Compaction* c);
|
|
|
|
|
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);
|
|
|
|
|
2012-06-23 04:30:03 +02:00
|
|
|
double MaxBytesForLevel(int level);
|
|
|
|
|
|
|
|
uint64_t MaxFileSizeForLevel(int level);
|
|
|
|
|
2012-08-29 21:29:43 +02:00
|
|
|
int64_t ExpandedCompactionByteSizeLimit(int level);
|
2012-06-23 04:30:03 +02:00
|
|
|
|
2012-08-29 21:29:43 +02:00
|
|
|
int64_t MaxGrandParentOverlapBytes(int level);
|
2012-06-23 04:30:03 +02:00
|
|
|
|
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_;
|
2011-04-12 21:38:58 +02:00
|
|
|
uint64_t last_sequence_;
|
|
|
|
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
|
|
|
|
WritableFile* descriptor_file_;
|
|
|
|
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
|
|
|
|
|
|
|
// Per-level key at which the next compaction at that level should start.
|
|
|
|
// Either an empty string, or a valid InternalKey.
|
2012-06-23 04:30:03 +02:00
|
|
|
std::string* compact_pointer_;
|
|
|
|
|
|
|
|
// Per-level target file size.
|
|
|
|
uint64_t* max_file_size_;
|
|
|
|
|
|
|
|
// Per-level max bytes
|
|
|
|
uint64_t* level_max_bytes_;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// record all the ongoing compactions for all levels
|
|
|
|
std::vector<std::set<Compaction*> > compactions_in_progress_;
|
|
|
|
|
|
|
|
// 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_;
|
|
|
|
|
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
|
|
|
|
|
|
|
// Return the total amount of data that is undergoing
|
|
|
|
// compactions at this level
|
|
|
|
uint64_t SizeBeingCompacted(int level);
|
|
|
|
|
|
|
|
// Returns true if any one of the parent files are being compacted
|
Assertion failure while running with unit tests with OPT=-g
Summary:
When we expand the range of keys for a level 0 compaction, we
need to invoke ParentFilesInCompaction() only once for the
entire range of keys that is being compacted. We were invoking
it for each file that was being compacted, but this triggers
an assertion because each file's range were contiguous but
non-overlapping.
I renamed ParentFilesInCompaction to ParentRangeInCompaction
to adequately represent that it is the range-of-keys and
not individual files that we compact in a single compaction run.
Here is the assertion that is fixed by this patch.
db_test: db/version_set.cc:585: void leveldb::Version::ExtendOverlappingInputs(int, const leveldb::Slice&, const leveldb::Slice&, std::vector<leveldb::FileMetaData*, std::allocator<leveldb::FileMetaData*> >*, int): Assertion `user_cmp->Compare(flimit, user_begin) >= 0' failed.
Test Plan: make clean check OPT=-g
Reviewers: sheki
Reviewed By: sheki
CC: MarkCallaghan, emayanke, leveldb
Differential Revision: https://reviews.facebook.net/D6963
2012-11-26 10:49:50 +01:00
|
|
|
bool ParentRangeInCompaction(const InternalKey* smallest,
|
|
|
|
const InternalKey* largest, int level, int* index);
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
// Returns true if any one of the specified files are being compacted
|
|
|
|
bool FilesInCompaction(std::vector<FileMetaData*>& files);
|
|
|
|
|
|
|
|
void LogAndApplyHelper(Builder*b, Version* v,
|
|
|
|
VersionEdit* edit, port::Mutex* mu);
|
2011-03-18 23:37:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
// A Compaction encapsulates information about a compaction.
|
|
|
|
class Compaction {
|
|
|
|
public:
|
|
|
|
~Compaction();
|
|
|
|
|
|
|
|
// Return the level that is being compacted. Inputs from "level"
|
|
|
|
// and "level+1" will be merged to produce a set of "level+1" files.
|
|
|
|
int level() const { return level_; }
|
|
|
|
|
|
|
|
// Return the object that holds the edits to the descriptor done
|
|
|
|
// by this compaction.
|
2012-06-23 04:30:03 +02:00
|
|
|
VersionEdit* edit() { return edit_; }
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// "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_; }
|
|
|
|
|
2011-03-22 19:32:49 +01:00
|
|
|
// 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;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// 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);
|
|
|
|
|
2011-03-22 19:32:49 +01:00
|
|
|
// Returns true iff we should stop building the current output
|
2011-05-21 04:17:43 +02:00
|
|
|
// before processing "internal_key".
|
|
|
|
bool ShouldStopBefore(const Slice& internal_key);
|
2011-03-22 19:32:49 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Release the input version for the compaction, once the compaction
|
|
|
|
// is successful.
|
|
|
|
void ReleaseInputs();
|
|
|
|
|
2012-08-18 03:10:09 +02:00
|
|
|
void Summary(char* output, int len);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
private:
|
|
|
|
friend class Version;
|
|
|
|
friend class VersionSet;
|
|
|
|
|
2012-06-23 04:30:03 +02:00
|
|
|
explicit Compaction(int level, uint64_t target_file_size,
|
2012-10-20 01:41:34 +02:00
|
|
|
uint64_t max_grandparent_overlap_bytes, int number_levels,
|
|
|
|
bool seek_compaction = false);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
int level_;
|
|
|
|
uint64_t max_output_file_size_;
|
2012-08-29 21:29:43 +02:00
|
|
|
int64_t maxGrandParentOverlapBytes_;
|
2011-03-18 23:37:00 +01:00
|
|
|
Version* input_version_;
|
2012-06-23 04:30:03 +02:00
|
|
|
VersionEdit* edit_;
|
|
|
|
int number_levels_;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-20 01:41:34 +02:00
|
|
|
bool seek_compaction_;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Each compaction reads inputs from "level_" and "level_+1"
|
|
|
|
std::vector<FileMetaData*> inputs_[2]; // The two sets of inputs
|
|
|
|
|
2011-03-22 19:32:49 +01:00
|
|
|
// State used to check for number of of overlapping grandparent files
|
|
|
|
// (parent == level_ + 1, grandparent == level_ + 2)
|
|
|
|
std::vector<FileMetaData*> grandparents_;
|
2011-04-21 00:48:11 +02:00
|
|
|
size_t grandparent_index_; // Index in grandparent_starts_
|
2011-03-23 00:24:02 +01:00
|
|
|
bool seen_key_; // Some output key has been seen
|
|
|
|
int64_t overlapped_bytes_; // Bytes of overlap between current output
|
|
|
|
// and grandparent files
|
2012-11-06 18:06:16 +01:00
|
|
|
int base_index_; // index of the file in files_[level_]
|
|
|
|
int parent_index_; // index of some file with same range in files_[level_+1]
|
2011-03-22 19:32:49 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// State for implementing IsBaseLevelForKey
|
|
|
|
|
|
|
|
// 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).
|
2012-06-23 04:30:03 +02:00
|
|
|
size_t* level_ptrs_;
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
// mark (or clear) all files that are being compacted
|
|
|
|
void MarkFilesBeingCompacted(bool);
|
2012-11-01 06:01:57 +01:00
|
|
|
|
|
|
|
// 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();
|
2011-03-18 23:37:00 +01:00
|
|
|
};
|
|
|
|
|
2011-10-31 18:22:06 +01:00
|
|
|
} // namespace leveldb
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
#endif // STORAGE_LEVELDB_DB_VERSION_SET_H_
|