src/leveldb/db/db_impl.h

   1 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   4
   5 #ifndef STORAGE_LEVELDB_DB_DB_IMPL_H_
   6 #define STORAGE_LEVELDB_DB_DB_IMPL_H_
   7
   8 #include <deque>
   9 #include <set>
  10 #include "db/dbformat.h"
  11 #include "db/log_writer.h"
  12 #include "db/snapshot.h"
  13 #include "leveldb/db.h"
  14 #include "leveldb/env.h"
  15 #include "port/port.h"
  16 #include "port/thread_annotations.h"
  17
  18 namespace leveldb {
  19
  20 class MemTable;
  21 class TableCache;
  22 class Version;
  23 class VersionEdit;
  24 class VersionSet;
  25
  26 class DBImpl : public DB {
  27  public:
  28   DBImpl(const Options& options, const std::string& dbname);
  29   virtual ~DBImpl();
  30
  31   // Implementations of the DB interface
  32   virtual Status Put(const WriteOptions&, const Slice& key, const Slice& value);
  33   virtual Status Delete(const WriteOptions&, const Slice& key);
  34   virtual Status Write(const WriteOptions& options, WriteBatch* updates);
  35   virtual Status Get(const ReadOptions& options,
  36                      const Slice& key,
  37                      std::string* value);
  38   virtual Iterator* NewIterator(const ReadOptions&);
  39   virtual const Snapshot* GetSnapshot();
  40   virtual void ReleaseSnapshot(const Snapshot* snapshot);
  41   virtual bool GetProperty(const Slice& property, std::string* value);
  42   virtual void GetApproximateSizes(const Range* range, int n, uint64_t* sizes);
  43   virtual void CompactRange(const Slice* begin, const Slice* end);
  44
  45   // Extra methods (for testing) that are not in the public DB interface
  46
  47   // Compact any files in the named level that overlap [*begin,*end]
  48   void TEST_CompactRange(int level, const Slice* begin, const Slice* end);
  49
  50   // Force current memtable contents to be compacted.
  51   Status TEST_CompactMemTable();
  52
  53   // Return an internal iterator over the current state of the database.
  54   // The keys of this iterator are internal keys (see format.h).
  55   // The returned iterator should be deleted when no longer needed.
  56   Iterator* TEST_NewInternalIterator();
  57
  58   // Return the maximum overlapping data (in bytes) at next level for any
  59   // file at a level >= 1.
  60   int64_t TEST_MaxNextLevelOverlappingBytes();
  61
  62  private:
  63   friend class DB;
  64   struct CompactionState;
  65   struct Writer;
  66
  67   Iterator* NewInternalIterator(const ReadOptions&,
  68                                 SequenceNumber* latest_snapshot);
  69
  70   Status NewDB();
  71
  72   // Recover the descriptor from persistent storage.  May do a significant
  73   // amount of work to recover recently logged updates.  Any changes to
  74   // be made to the descriptor are added to *edit.
  75   Status Recover(VersionEdit* edit) EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  76
  77   void MaybeIgnoreError(Status* s) const;
  78
  79   // Delete any unneeded files and stale in-memory entries.
  80   void DeleteObsoleteFiles();
  81
  82   // Compact the in-memory write buffer to disk.  Switches to a new
  83   // log-file/memtable and writes a new descriptor iff successful.
  84   Status CompactMemTable()
  85       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  86
  87   Status RecoverLogFile(uint64_t log_number,
  88                         VersionEdit* edit,
  89                         SequenceNumber* max_sequence)
  90       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  91
  92   Status WriteLevel0Table(MemTable* mem, VersionEdit* edit, Version* base)
  93       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  94
  95   Status MakeRoomForWrite(bool force /* compact even if there is room? */)
  96       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  97   WriteBatch* BuildBatchGroup(Writer** last_writer);
  98
  99   void MaybeScheduleCompaction() EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 100   static void BGWork(void* db);
 101   void BackgroundCall();
 102   Status BackgroundCompaction() EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 103   void CleanupCompaction(CompactionState* compact)
 104       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 105   Status DoCompactionWork(CompactionState* compact)
 106       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 107
 108   Status OpenCompactionOutputFile(CompactionState* compact);
 109   Status FinishCompactionOutputFile(CompactionState* compact, Iterator* input);
 110   Status InstallCompactionResults(CompactionState* compact)
 111       EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 112
 113   // Constant after construction
 114   Env* const env_;
 115   const InternalKeyComparator internal_comparator_;
 116   const InternalFilterPolicy internal_filter_policy_;
 117   const Options options_;  // options_.comparator == &internal_comparator_
 118   bool owns_info_log_;
 119   bool owns_cache_;
 120   const std::string dbname_;
 121
 122   // table_cache_ provides its own synchronization
 123   TableCache* table_cache_;
 124
 125   // Lock over the persistent DB state.  Non-NULL iff successfully acquired.
 126   FileLock* db_lock_;
 127
 128   // State below is protected by mutex_
 129   port::Mutex mutex_;
 130   port::AtomicPointer shutting_down_;
 131   port::CondVar bg_cv_;          // Signalled when background work finishes
 132   MemTable* mem_;
 133   MemTable* imm_;                // Memtable being compacted
 134   port::AtomicPointer has_imm_;  // So bg thread can detect non-NULL imm_
 135   WritableFile* logfile_;
 136   uint64_t logfile_number_;
 137   log::Writer* log_;
 138
 139   // Queue of writers.
 140   std::deque<Writer*> writers_;
 141   WriteBatch* tmp_batch_;
 142
 143   SnapshotList snapshots_;
 144
 145   // Set of table files to protect from deletion because they are
 146   // part of ongoing compactions.
 147   std::set<uint64_t> pending_outputs_;
 148
 149   // Has a background compaction been scheduled or is running?
 150   bool bg_compaction_scheduled_;
 151
 152   // Information for a manual compaction
 153   struct ManualCompaction {
 154     int level;
 155     bool done;
 156     const InternalKey* begin;   // NULL means beginning of key range
 157     const InternalKey* end;     // NULL means end of key range
 158     InternalKey tmp_storage;    // Used to keep track of compaction progress
 159   };
 160   ManualCompaction* manual_compaction_;
 161
 162   VersionSet* versions_;
 163
 164   // Have we encountered a background error in paranoid mode?
 165   Status bg_error_;
 166   int consecutive_compaction_errors_;
 167
 168   // Per level compaction stats.  stats_[level] stores the stats for
 169   // compactions that produced data for the specified "level".
 170   struct CompactionStats {
 171     int64_t micros;
 172     int64_t bytes_read;
 173     int64_t bytes_written;
 174
 175     CompactionStats() : micros(0), bytes_read(0), bytes_written(0) { }
 176
 177     void Add(const CompactionStats& c) {
 178       this->micros += c.micros;
 179       this->bytes_read += c.bytes_read;
 180       this->bytes_written += c.bytes_written;
 181     }
 182   };
 183   CompactionStats stats_[config::kNumLevels];
 184
 185   // No copying allowed
 186   DBImpl(const DBImpl&);
 187   void operator=(const DBImpl&);
 188
 189   const Comparator* user_comparator() const {
 190     return internal_comparator_.user_comparator();
 191   }
 192 };
 193
 194 // Sanitize db options.  The caller should delete result.info_log if
 195 // it is not equal to src.info_log.
 196 extern Options SanitizeOptions(const std::string& db,
 197                                const InternalKeyComparator* icmp,
 198                                const InternalFilterPolicy* ipolicy,
 199                                const Options& src);
 200
 201 }  // namespace leveldb
 202
 203 #endif  // STORAGE_LEVELDB_DB_DB_IMPL_H_