leveldb::VersionSet Class Reference

#include <version_set.h>

Collaboration diagram for leveldb::VersionSet:

Classes
class	Builder
struct	LevelSummaryStorage

Public Member Functions
	VersionSet (const std::string &dbname, const Options *options, TableCache *table_cache, const InternalKeyComparator *)
	~VersionSet ()
Status	LogAndApply (VersionEdit *edit, port::Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(mu)
Status	Recover (bool *save_manifest)
Version *	current () const
uint64_t	ManifestFileNumber () const
uint64_t	NewFileNumber ()
void	ReuseFileNumber (uint64_t file_number)
int	NumLevelFiles (int level) const
int64_t	NumLevelBytes (int level) const
uint64_t	LastSequence () const
void	SetLastSequence (uint64_t s)
void	MarkFileNumberUsed (uint64_t number)
uint64_t	LogNumber () const
uint64_t	PrevLogNumber () const
Compaction *	PickCompaction ()
Compaction *	CompactRange (int level, const InternalKey *begin, const InternalKey *end)
int64_t	MaxNextLevelOverlappingBytes ()
Iterator *	MakeInputIterator (Compaction *c)
bool	NeedsCompaction () const
void	AddLiveFiles (std::set< uint64_t > *live)
uint64_t	ApproximateOffsetOf (Version *v, const InternalKey &key)
const char *	LevelSummary (LevelSummaryStorage *scratch) const

Private Member Functions
bool	ReuseManifest (const std::string &dscname, const std::string &dscbase)
void	Finalize (Version *v)
void	GetRange (const std::vector< FileMetaData *> &inputs, InternalKey *smallest, InternalKey *largest)
void	GetRange2 (const std::vector< FileMetaData *> &inputs1, const std::vector< FileMetaData *> &inputs2, InternalKey *smallest, InternalKey *largest)
void	SetupOtherInputs (Compaction *c)
Status	WriteSnapshot (log::Writer *log)
void	AppendVersion (Version *v)
	VersionSet (const VersionSet &)
void	operator= (const VersionSet &)

Private Attributes
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_
uint64_t	last_sequence_
uint64_t	log_number_
uint64_t	prev_log_number_
WritableFile *	descriptor_file_
log::Writer *	descriptor_log_
Version	dummy_versions_
Version *	current_
std::string	compact_pointer_ [config::kNumLevels]

Friends
class	Compaction
class	Version

Detailed Description

Definition at line 165 of file version_set.h.

---

Class Documentation

leveldb::VersionSet::LevelSummaryStorage

struct leveldb::VersionSet::LevelSummaryStorage

Definition at line 266 of file version_set.h.

Class Members
char	buffer[100]

Constructor & Destructor Documentation

VersionSet() [1/2]

leveldb::VersionSet::VersionSet	(	const std::string &	dbname,
		const Options *	options,
		TableCache *	table_cache,
		const InternalKeyComparator *	cmp
	)

Definition at line 775 of file version_set.cc.

    : 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));
}

Here is the call graph for this function:

~VersionSet()

leveldb::VersionSet::~VersionSet

(

)

Definition at line 796 of file version_set.cc.

                        {
  current_->Unref();
  assert(dummy_versions_.next_ == &dummy_versions_);  // List must be empty
  delete descriptor_log_;
  delete descriptor_file_;
}

Here is the call graph for this function:

VersionSet() [2/2]

leveldb::VersionSet::VersionSet ( const VersionSet &  )

private

Member Function Documentation

AddLiveFiles()

void leveldb::VersionSet::AddLiveFiles

(

std::set< uint64_t > *

live

)

Definition at line 1185 of file version_set.cc.

                                                    {
  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);
      }
    }
  }
}

Here is the caller graph for this function:

AppendVersion()

void leveldb::VersionSet::AppendVersion ( Version *  v )

private

Definition at line 803 of file version_set.cc.

                                         {
  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ApproximateOffsetOf()

uint64_t leveldb::VersionSet::ApproximateOffsetOf	(	Version *	v,
		const InternalKey &	key
	)

Definition at line 1153 of file version_set.cc.

                                                                            {
  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" 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CompactRange()

Compaction * leveldb::VersionSet::CompactRange	(	int	level,
		const InternalKey *	begin,
		const InternalKey *	end
	)

Definition at line 1413 of file version_set.cc.

                            {
  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.
  // But we cannot do this for level-0 since level-0 files can overlap
  // and we must not pick one file and drop another older file if the
  // two files overlap.
  if (level > 0) {
    const uint64_t limit = MaxFileSizeForLevel(options_, level);
    uint64_t total = 0;
    for (size_t 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(options_, level);
  c->input_version_ = current_;
  c->input_version_->Ref();
  c->inputs_[0] = inputs;
  SetupOtherInputs(c);
  return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

current()

Version* leveldb::VersionSet::current ( ) const

inline

Definition at line 185 of file version_set.h.

{ return current_; }

Here is the caller graph for this function:

Finalize()

void leveldb::VersionSet::Finalize ( Version *  v )

private

Definition at line 1064 of file version_set.cc.

                                    {
  // 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) {
      // 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(options_, level);
    }

    if (score > best_score) {
      best_level = level;
      best_score = score;
    }
  }

  v->compaction_level_ = best_level;
  v->compaction_score_ = best_score;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRange()

void leveldb::VersionSet::GetRange ( const std::vector< FileMetaData *> &  inputs, InternalKey *  smallest, InternalKey *  largest  )

private

Definition at line 1224 of file version_set.cc.

                                                {
  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;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRange2()

void leveldb::VersionSet::GetRange2 ( const std::vector< FileMetaData *> &  inputs1, const std::vector< FileMetaData *> &  inputs2, InternalKey *  smallest, InternalKey *  largest  )

private

Definition at line 1249 of file version_set.cc.

                                                 {
  std::vector<FileMetaData*> all = inputs1;
  all.insert(all.end(), inputs2.begin(), inputs2.end());
  GetRange(all, smallest, largest);
}

Here is the call graph for this function:

Here is the caller graph for this function:

LastSequence()

uint64_t leveldb::VersionSet::LastSequence ( ) const

inline

Definition at line 209 of file version_set.h.

{ return last_sequence_; }

Here is the caller graph for this function:

LevelSummary()

const char * leveldb::VersionSet::LevelSummary

(

LevelSummaryStorage *

scratch

)

const

Definition at line 1138 of file version_set.cc.

                                                                       {
  // 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;
}

Here is the caller graph for this function:

LogAndApply()

Status leveldb::VersionSet::LogAndApply	(	VersionEdit *	edit,
		port::Mutex *	mu
	)

Definition at line 820 of file version_set.cc.

                                                               {
  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_);
      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);
      s = descriptor_log_->AddRecord(record);
      if (s.ok()) {
        s = descriptor_file_->Sync();
      }
      if (!s.ok()) {
        Log(options_->info_log, "MANIFEST write: %s\n", s.ToString().c_str());
      }
    }

    // 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_);
    }

    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogNumber()

uint64_t leveldb::VersionSet::LogNumber ( ) const

inline

Definition at line 221 of file version_set.h.

{ return log_number_; }

Here is the caller graph for this function:

MakeInputIterator()

Iterator * leveldb::VersionSet::MakeInputIterator

(

Compaction *

c

)

Definition at line 1258 of file version_set.cc.

                                                     {
  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 : 2);
  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) {
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ManifestFileNumber()

uint64_t leveldb::VersionSet::ManifestFileNumber ( ) const

inline

Definition at line 188 of file version_set.h.

{ return manifest_file_number_; }

Here is the caller graph for this function:

MarkFileNumberUsed()

void leveldb::VersionSet::MarkFileNumberUsed

(

uint64_t

number

)

Definition at line 1058 of file version_set.cc.

                                                   {
  if (next_file_number_ <= number) {
    next_file_number_ = number + 1;
  }
}

Here is the caller graph for this function:

MaxNextLevelOverlappingBytes()

int64_t leveldb::VersionSet::MaxNextLevelOverlappingBytes

(

)

Definition at line 1204 of file version_set.cc.

                                                 {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NeedsCompaction()

bool leveldb::VersionSet::NeedsCompaction ( ) const

inline

Definition at line 251 of file version_set.h.

                               {
    Version* v = current_;
    return (v->compaction_score_ >= 1) || (v->file_to_compact_ != NULL);
  }

Here is the caller graph for this function:

NewFileNumber()

uint64_t leveldb::VersionSet::NewFileNumber ( )

inline

Definition at line 191 of file version_set.h.

{ return next_file_number_++; }

Here is the caller graph for this function:

NumLevelBytes()

int64_t leveldb::VersionSet::NumLevelBytes

(

int

level

)

const

Definition at line 1198 of file version_set.cc.

                                                 {
  assert(level >= 0);
  assert(level < config::kNumLevels);
  return TotalFileSize(current_->files_[level]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumLevelFiles()

int leveldb::VersionSet::NumLevelFiles

(

int

level

)

const

Definition at line 1132 of file version_set.cc.

                                             {
  assert(level >= 0);
  assert(level < config::kNumLevels);
  return current_->files_[level].size();
}

Here is the caller graph for this function:

operator=()

void leveldb::VersionSet::operator= ( const VersionSet &  )

private

PickCompaction()

Compaction * leveldb::VersionSet::PickCompaction

(

)

Definition at line 1291 of file version_set.cc.

                                       {
  Compaction* c;
  int level;

  // We prefer compactions triggered by too much data in a level over
  // the compactions triggered by seeks.
  const bool size_compaction = (current_->compaction_score_ >= 1);
  const bool seek_compaction = (current_->file_to_compact_ != NULL);
  if (size_compaction) {
    level = current_->compaction_level_;
    assert(level >= 0);
    assert(level+1 < config::kNumLevels);
    c = new Compaction(options_, level);

    // Pick the first file that comes after compact_pointer_[level]
    for (size_t i = 0; i < current_->files_[level].size(); i++) {
      FileMetaData* f = current_->files_[level][i];
      if (compact_pointer_[level].empty() ||
          icmp_.Compare(f->largest.Encode(), compact_pointer_[level]) > 0) {
        c->inputs_[0].push_back(f);
        break;
      }
    }
    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(options_, level);
    c->inputs_[0].push_back(current_->file_to_compact_);
  } else {
    return NULL;
  }

  c->input_version_ = current_;
  c->input_version_->Ref();

  // 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.
    current_->GetOverlappingInputs(0, &smallest, &largest, &c->inputs_[0]);
    assert(!c->inputs_[0].empty());
  }

  SetupOtherInputs(c);

  return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrevLogNumber()

uint64_t leveldb::VersionSet::PrevLogNumber ( ) const

inline

Definition at line 225 of file version_set.h.

{ return prev_log_number_; }

Here is the caller graph for this function:

Recover()

Status leveldb::VersionSet::Recover

(

bool *

save_manifest

)

Definition at line 905 of file version_set.cc.

                                              {
  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_), &current);
  if (!s.ok()) {
    return s;
  }
  if (current.empty() || current[current.size()-1] != '\n') {
    return Status::Corruption("CURRENT file does not end with newline");
  }
  current.resize(current.size() - 1);

  std::string dscname = dbname_ + "/" + current;
  SequentialFile* file;
  s = env_->NewSequentialFile(dscname, &file);
  if (!s.ok()) {
    return s;
  }

  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_);

  {
    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()) {
        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;

  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);
  }

  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;

    // See if we can reuse the existing MANIFEST file.
    if (ReuseManifest(dscname, current)) {
      // No need to save new manifest
    } else {
      *save_manifest = true;
    }
  }

  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReuseFileNumber()

void leveldb::VersionSet::ReuseFileNumber ( uint64_t  file_number )

inline

Definition at line 196 of file version_set.h.

                                             {
    if (next_file_number_ == file_number + 1) {
      next_file_number_ = file_number;
    }
  }

Here is the caller graph for this function:

ReuseManifest()

bool leveldb::VersionSet::ReuseManifest ( const std::string &  dscname, const std::string &  dscbase  )

private

Definition at line 1027 of file version_set.cc.

                                                         {
  if (!options_->reuse_logs) {
    return false;
  }
  FileType manifest_type;
  uint64_t manifest_number;
  uint64_t manifest_size;
  if (!ParseFileName(dscbase, &manifest_number, &manifest_type) ||
      manifest_type != kDescriptorFile ||
      !env_->GetFileSize(dscname, &manifest_size).ok() ||
      // Make new compacted MANIFEST if old one is too big
      manifest_size >= TargetFileSize(options_)) {
    return false;
  }

  assert(descriptor_file_ == NULL);
  assert(descriptor_log_ == NULL);
  Status r = env_->NewAppendableFile(dscname, &descriptor_file_);
  if (!r.ok()) {
    Log(options_->info_log, "Reuse MANIFEST: %s\n", r.ToString().c_str());
    assert(descriptor_file_ == NULL);
    return false;
  }

  Log(options_->info_log, "Reusing MANIFEST %s\n", dscname.c_str());
  descriptor_log_ = new log::Writer(descriptor_file_, manifest_size);
  manifest_file_number_ = manifest_number;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastSequence()

void leveldb::VersionSet::SetLastSequence ( uint64_t  s )

inline

Definition at line 212 of file version_set.h.

                                   {
    assert(s >= last_sequence_);
    last_sequence_ = s;
  }

Here is the caller graph for this function:

SetupOtherInputs()

void leveldb::VersionSet::SetupOtherInputs ( Compaction *  c )

private

Definition at line 1345 of file version_set.cc.

                                               {
  const int level = c->level();
  InternalKey smallest, largest;
  GetRange(c->inputs_[0], &smallest, &largest);

  current_->GetOverlappingInputs(level+1, &smallest, &largest, &c->inputs_[1]);

  // Get entire range covered by compaction
  InternalKey all_start, all_limit;
  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;
    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);
    if (expanded0.size() > c->inputs_[0].size() &&
        inputs1_size + expanded0_size <
            ExpandedCompactionByteSizeLimit(options_)) {
      InternalKey new_start, new_limit;
      GetRange(expanded0, &new_start, &new_limit);
      std::vector<FileMetaData*> expanded1;
      current_->GetOverlappingInputs(level+1, &new_start, &new_limit,
                                     &expanded1);
      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 = new_limit;
        c->inputs_[0] = expanded0;
        c->inputs_[1] = expanded1;
        GetRange2(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);
      }
    }
  }

  // Compute the set of grandparent files that overlap this compaction
  // (parent == level+1; grandparent == level+2)
  if (level + 2 < config::kNumLevels) {
    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.
  compact_pointer_[level] = largest.Encode().ToString();
  c->edit_.SetCompactPointer(level, largest);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WriteSnapshot()

Status leveldb::VersionSet::WriteSnapshot ( log::Writer *  log )

private

Definition at line 1102 of file version_set.cc.

                                               {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

Compaction

friend class Compaction

friend

Definition at line 272 of file version_set.h.

Version

friend class Version

friend

Definition at line 275 of file version_set.h.

Member Data Documentation

compact_pointer_

std::string leveldb::VersionSet::compact_pointer_[config::kNumLevels]

private

Definition at line 316 of file version_set.h.

current_

Version* leveldb::VersionSet::current_

private

Definition at line 312 of file version_set.h.

dbname_

const std::string leveldb::VersionSet::dbname_

private

Definition at line 298 of file version_set.h.

descriptor_file_

WritableFile* leveldb::VersionSet::descriptor_file_

private

Definition at line 309 of file version_set.h.

descriptor_log_

log::Writer* leveldb::VersionSet::descriptor_log_

private

Definition at line 310 of file version_set.h.

dummy_versions_

Version leveldb::VersionSet::dummy_versions_

private

Definition at line 311 of file version_set.h.

env_

Env* const leveldb::VersionSet::env_

private

Definition at line 297 of file version_set.h.

icmp_

const InternalKeyComparator leveldb::VersionSet::icmp_

private

Definition at line 301 of file version_set.h.

last_sequence_

uint64_t leveldb::VersionSet::last_sequence_

private

Definition at line 304 of file version_set.h.

log_number_

uint64_t leveldb::VersionSet::log_number_

private

Definition at line 305 of file version_set.h.

manifest_file_number_

uint64_t leveldb::VersionSet::manifest_file_number_

private

Definition at line 303 of file version_set.h.

next_file_number_

uint64_t leveldb::VersionSet::next_file_number_

private

Definition at line 302 of file version_set.h.

options_

const Options* const leveldb::VersionSet::options_

private

Definition at line 299 of file version_set.h.

prev_log_number_

uint64_t leveldb::VersionSet::prev_log_number_

private

Definition at line 306 of file version_set.h.

table_cache_

TableCache* const leveldb::VersionSet::table_cache_

private

Definition at line 300 of file version_set.h.

---

The documentation for this class was generated from the following files:

• db/version_set.h
• db/version_set.cc