leveldb::VersionSet::Builder Class Reference

Collaboration diagram for leveldb::VersionSet::Builder:

Classes
struct	BySmallestKey
struct	LevelState

Public Member Functions
	Builder (VersionSet *vset, Version *base)
	~Builder ()
void	Apply (VersionEdit *edit)
void	SaveTo (Version *v)
void	MaybeAddFile (Version *v, int level, FileMetaData *f)

Private Types
typedef std::set< FileMetaData *, BySmallestKey >	FileSet

Private Attributes
VersionSet *	vset_
Version *	base_
LevelState	levels_ [config::kNumLevels]

Detailed Description

Definition at line 603 of file version_set.cc.

---

Class Documentation

leveldb::VersionSet::Builder::LevelState

struct leveldb::VersionSet::Builder::LevelState

Definition at line 621 of file version_set.cc.

Class Members
FileSet *	added_files
set< uint64_t >	deleted_files

Member Typedef Documentation

FileSet

typedef std::set<FileMetaData*, BySmallestKey> leveldb::VersionSet::Builder::FileSet

private

Definition at line 620 of file version_set.cc.

Constructor & Destructor Documentation

Builder()

leveldb::VersionSet::Builder::Builder ( VersionSet *  vset, Version *  base  )

inline

Definition at line 632 of file version_set.cc.

      : vset_(vset),
        base_(base) {
    base_->Ref();
    BySmallestKey cmp;
    cmp.internal_comparator = &vset_->icmp_;
    for (int level = 0; level < config::kNumLevels; level++) {
      levels_[level].added_files = new FileSet(cmp);
    }
  }

Here is the call graph for this function:

~Builder()

leveldb::VersionSet::Builder::~Builder ( )

inline

Definition at line 643 of file version_set.cc.

             {
    for (int level = 0; level < config::kNumLevels; level++) {
      const FileSet* added = levels_[level].added_files;
      std::vector<FileMetaData*> to_unref;
      to_unref.reserve(added->size());
      for (FileSet::const_iterator it = added->begin();
          it != added->end(); ++it) {
        to_unref.push_back(*it);
      }
      delete added;
      for (uint32_t i = 0; i < to_unref.size(); i++) {
        FileMetaData* f = to_unref[i];
        f->refs--;
        if (f->refs <= 0) {
          delete f;
        }
      }
    }
    base_->Unref();
  }

Here is the call graph for this function:

Member Function Documentation

Apply()

void leveldb::VersionSet::Builder::Apply ( VersionEdit *  edit )

inline

Definition at line 665 of file version_set.cc.

                                {
    // Update compaction pointers
    for (size_t i = 0; i < edit->compact_pointers_.size(); i++) {
      const int level = edit->compact_pointers_[i].first;
      vset_->compact_pointer_[level] =
          edit->compact_pointers_[i].second.Encode().ToString();
    }

    // Delete files
    const VersionEdit::DeletedFileSet& del = edit->deleted_files_;
    for (VersionEdit::DeletedFileSet::const_iterator iter = del.begin();
         iter != del.end();
         ++iter) {
      const int level = iter->first;
      const uint64_t number = iter->second;
      levels_[level].deleted_files.insert(number);
    }

    // Add new files
    for (size_t i = 0; i < edit->new_files_.size(); i++) {
      const int level = edit->new_files_[i].first;
      FileMetaData* f = new FileMetaData(edit->new_files_[i].second);
      f->refs = 1;

      // We arrange to automatically compact this file after
      // a certain number of seeks.  Let's assume:
      //   (1) One seek costs 10ms
      //   (2) Writing or reading 1MB costs 10ms (100MB/s)
      //   (3) A compaction of 1MB does 25MB of IO:
      //         1MB read from this level
      //         10-12MB read from next level (boundaries may be misaligned)
      //         10-12MB written to next level
      // This implies that 25 seeks cost the same as the compaction
      // of 1MB of data.  I.e., one seek costs approximately the
      // same as the compaction of 40KB of data.  We are a little
      // conservative and allow approximately one seek for every 16KB
      // of data before triggering a compaction.
      f->allowed_seeks = (f->file_size / 16384);
      if (f->allowed_seeks < 100) f->allowed_seeks = 100;

      levels_[level].deleted_files.erase(f->number);
      levels_[level].added_files->insert(f);
    }
  }

Here is the caller graph for this function:

MaybeAddFile()

void leveldb::VersionSet::Builder::MaybeAddFile ( Version *  v, int  level, FileMetaData *  f  )

inline

Definition at line 759 of file version_set.cc.

                                                            {
    if (levels_[level].deleted_files.count(f->number) > 0) {
      // File is deleted: do nothing
    } else {
      std::vector<FileMetaData*>* files = &v->files_[level];
      if (level > 0 && !files->empty()) {
        // Must not overlap
        assert(vset_->icmp_.Compare((*files)[files->size()-1]->largest,
                                    f->smallest) < 0);
      }
      f->refs++;
      files->push_back(f);
    }
  }

Here is the call graph for this function:

SaveTo()

void leveldb::VersionSet::Builder::SaveTo ( Version *  v )

inline

Definition at line 711 of file version_set.cc.

                          {
    BySmallestKey cmp;
    cmp.internal_comparator = &vset_->icmp_;
    for (int level = 0; level < config::kNumLevels; level++) {
      // Merge the set of added files with the set of pre-existing files.
      // Drop any deleted files.  Store the result in *v.
      const std::vector<FileMetaData*>& base_files = base_->files_[level];
      std::vector<FileMetaData*>::const_iterator base_iter = base_files.begin();
      std::vector<FileMetaData*>::const_iterator base_end = base_files.end();
      const FileSet* added = levels_[level].added_files;
      v->files_[level].reserve(base_files.size() + added->size());
      for (FileSet::const_iterator added_iter = added->begin();
           added_iter != added->end();
           ++added_iter) {
        // Add all smaller files listed in base_
        for (std::vector<FileMetaData*>::const_iterator bpos
                 = std::upper_bound(base_iter, base_end, *added_iter, cmp);
             base_iter != bpos;
             ++base_iter) {
          MaybeAddFile(v, level, *base_iter);
        }

        MaybeAddFile(v, level, *added_iter);
      }

      // Add remaining base files
      for (; base_iter != base_end; ++base_iter) {
        MaybeAddFile(v, level, *base_iter);
      }

#ifndef NDEBUG
      // Make sure there is no overlap in levels > 0
      if (level > 0) {
        for (uint32_t i = 1; i < v->files_[level].size(); i++) {
          const InternalKey& prev_end = v->files_[level][i-1]->largest;
          const InternalKey& this_begin = v->files_[level][i]->smallest;
          if (vset_->icmp_.Compare(prev_end, this_begin) >= 0) {
            fprintf(stderr, "overlapping ranges in same level %s vs. %s\n",
                    prev_end.DebugString().c_str(),
                    this_begin.DebugString().c_str());
            abort();
          }
        }
      }
#endif
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

base_

Version* leveldb::VersionSet::Builder::base_

private

Definition at line 627 of file version_set.cc.

levels_

LevelState leveldb::VersionSet::Builder::levels_[config::kNumLevels]

private

Definition at line 628 of file version_set.cc.

vset_

VersionSet* leveldb::VersionSet::Builder::vset_

private

Definition at line 626 of file version_set.cc.

---

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

• db/version_set.cc