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"
|
|
|
|
|
|
|
|
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
|
|
|
|
std::vector<FileMetaData*>* inputs);
|
|
|
|
|
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_;
|
|
|
|
|
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_;
|
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();
|
|
|
|
|
|
|
|
// 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()
|
|
|
|
Status LogAndApply(VersionEdit* edit, port::Mutex* mu);
|
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
|
|
|
|
|
|
|
// 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-06-23 04:30:03 +02:00
|
|
|
int NumberLevels() const { return options_->num_levels; }
|
|
|
|
|
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
|
|
|
|
|
|
|
// 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)
|
|
|
|
Status DumpManifest(Options& options, std::string& manifestFileName);
|
|
|
|
|
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
|
|
|
|
void ReleaseCompactionFiles(Compaction* c);
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
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-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
|
|
|
|
|
|
|
// 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_;
|
|
|
|
|
|
|
|
// A lock that serialize writes to the manifest
|
|
|
|
port::Mutex manifest_lock_;
|
|
|
|
|
|
|
|
// 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
|
|
|
|
bool ParentFilesInCompaction(FileMetaData* f, int level);
|
|
|
|
|
|
|
|
// 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
|
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);
|
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_
|