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.
|
|
|
|
|
|
|
|
#include "db/db_impl.h"
|
|
|
|
|
|
|
|
#include <algorithm>
|
2012-11-26 22:56:45 +01:00
|
|
|
#include <climits>
|
|
|
|
#include <cstdio>
|
2011-03-18 23:37:00 +01:00
|
|
|
#include <set>
|
|
|
|
#include <string>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <vector>
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
#include <unordered_set>
|
2012-11-26 22:56:45 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "db/builder.h"
|
|
|
|
#include "db/db_iter.h"
|
|
|
|
#include "db/dbformat.h"
|
|
|
|
#include "db/filename.h"
|
|
|
|
#include "db/log_reader.h"
|
|
|
|
#include "db/log_writer.h"
|
|
|
|
#include "db/memtable.h"
|
2012-10-19 23:00:53 +02:00
|
|
|
#include "db/memtablelist.h"
|
2013-03-21 23:59:47 +01:00
|
|
|
#include "db/merge_helper.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "db/table_cache.h"
|
|
|
|
#include "db/version_set.h"
|
|
|
|
#include "db/write_batch_internal.h"
|
2012-11-30 02:28:37 +01:00
|
|
|
#include "db/transaction_log_iterator_impl.h"
|
2013-05-12 11:36:59 +02:00
|
|
|
#include "leveldb/compaction_filter.h"
|
2011-03-30 20:35:40 +02:00
|
|
|
#include "leveldb/db.h"
|
|
|
|
#include "leveldb/env.h"
|
2013-03-21 23:59:47 +01:00
|
|
|
#include "leveldb/merge_operator.h"
|
2012-11-09 03:18:34 +01:00
|
|
|
#include "leveldb/statistics.h"
|
2011-03-30 20:35:40 +02:00
|
|
|
#include "leveldb/status.h"
|
|
|
|
#include "leveldb/table_builder.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "port/port.h"
|
|
|
|
#include "table/block.h"
|
|
|
|
#include "table/merger.h"
|
2013-04-23 00:20:20 +02:00
|
|
|
#include "table/table.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "table/two_level_iterator.h"
|
2013-02-15 20:53:17 +01:00
|
|
|
#include "util/auto_roll_logger.h"
|
|
|
|
#include "util/build_version.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
#include "util/coding.h"
|
|
|
|
#include "util/logging.h"
|
|
|
|
#include "util/mutexlock.h"
|
2013-02-15 20:53:17 +01:00
|
|
|
#include "util/stop_watch.h"
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
namespace leveldb {
|
|
|
|
|
2012-09-18 22:18:32 +02:00
|
|
|
void dumpLeveldbBuildVersion(Logger * log);
|
|
|
|
|
2012-03-09 01:23:21 +01:00
|
|
|
// Information kept for every waiting writer
|
|
|
|
struct DBImpl::Writer {
|
|
|
|
Status status;
|
|
|
|
WriteBatch* batch;
|
|
|
|
bool sync;
|
2012-07-05 22:39:28 +02:00
|
|
|
bool disableWAL;
|
2012-03-09 01:23:21 +01:00
|
|
|
bool done;
|
|
|
|
port::CondVar cv;
|
|
|
|
|
|
|
|
explicit Writer(port::Mutex* mu) : cv(mu) { }
|
|
|
|
};
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
struct DBImpl::CompactionState {
|
|
|
|
Compaction* const compaction;
|
|
|
|
|
2012-11-27 06:16:21 +01:00
|
|
|
// If there were two snapshots with seq numbers s1 and
|
|
|
|
// s2 and s1 < s2, and if we find two instances of a key k1 then lies
|
|
|
|
// entirely within s1 and s2, then the earlier version of k1 can be safely
|
|
|
|
// deleted because that version is not visible in any snapshot.
|
|
|
|
std::vector<SequenceNumber> existing_snapshots;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Files produced by compaction
|
|
|
|
struct Output {
|
|
|
|
uint64_t number;
|
|
|
|
uint64_t file_size;
|
|
|
|
InternalKey smallest, largest;
|
2013-06-14 07:09:08 +02:00
|
|
|
SequenceNumber smallest_seqno, largest_seqno;
|
2011-03-18 23:37:00 +01:00
|
|
|
};
|
|
|
|
std::vector<Output> outputs;
|
2012-10-19 23:00:53 +02:00
|
|
|
std::list<uint64_t> allocated_file_numbers;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// State kept for output being generated
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<WritableFile> outfile;
|
|
|
|
unique_ptr<TableBuilder> builder;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
uint64_t total_bytes;
|
|
|
|
|
|
|
|
Output* current_output() { return &outputs[outputs.size()-1]; }
|
|
|
|
|
|
|
|
explicit CompactionState(Compaction* c)
|
|
|
|
: compaction(c),
|
|
|
|
total_bytes(0) {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
struct DBImpl::DeletionState {
|
|
|
|
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
// the list of all live files that cannot be deleted
|
|
|
|
std::vector<uint64_t> live;
|
2012-10-21 10:49:48 +02:00
|
|
|
|
|
|
|
// a list of all siles that exists in the db directory
|
|
|
|
std::vector<std::string> allfiles;
|
|
|
|
|
|
|
|
// the current filenumber, lognumber and prevlognumber
|
|
|
|
// that corresponds to the set of files in 'live'.
|
|
|
|
uint64_t filenumber, lognumber, prevlognumber;
|
|
|
|
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
// the list of all files to be evicted from the table cache
|
2012-10-21 10:49:48 +02:00
|
|
|
std::vector<uint64_t> files_to_evict;
|
|
|
|
};
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Fix user-supplied options to be reasonable
|
2013-06-05 20:22:38 +02:00
|
|
|
template <class T, class V>
|
2011-03-18 23:37:00 +01:00
|
|
|
static void ClipToRange(T* ptr, V minvalue, V maxvalue) {
|
2011-04-21 00:48:11 +02:00
|
|
|
if (static_cast<V>(*ptr) > maxvalue) *ptr = maxvalue;
|
|
|
|
if (static_cast<V>(*ptr) < minvalue) *ptr = minvalue;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
Options SanitizeOptions(const std::string& dbname,
|
|
|
|
const InternalKeyComparator* icmp,
|
2012-04-17 17:36:46 +02:00
|
|
|
const InternalFilterPolicy* ipolicy,
|
2011-03-18 23:37:00 +01:00
|
|
|
const Options& src) {
|
|
|
|
Options result = src;
|
|
|
|
result.comparator = icmp;
|
2013-02-15 20:53:17 +01:00
|
|
|
result.filter_policy = (src.filter_policy != nullptr) ? ipolicy : nullptr;
|
2013-02-26 09:13:17 +01:00
|
|
|
ClipToRange(&result.max_open_files, 20, 1000000);
|
2013-05-23 20:56:19 +02:00
|
|
|
ClipToRange(&result.write_buffer_size, ((size_t)64)<<10,
|
|
|
|
((size_t)64)<<30);
|
2012-04-17 17:36:46 +02:00
|
|
|
ClipToRange(&result.block_size, 1<<10, 4<<20);
|
2013-06-11 23:23:58 +02:00
|
|
|
|
|
|
|
result.min_write_buffer_number_to_merge = std::min(
|
|
|
|
result.min_write_buffer_number_to_merge, result.max_write_buffer_number-1);
|
2013-02-15 20:53:17 +01:00
|
|
|
if (result.info_log == nullptr) {
|
2013-02-05 04:42:40 +01:00
|
|
|
Status s = CreateLoggerFromOptions(dbname, result.db_log_dir, src.env,
|
|
|
|
result, &result.info_log);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!s.ok()) {
|
|
|
|
// No place suitable for logging
|
2013-02-15 20:53:17 +01:00
|
|
|
result.info_log = nullptr;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
2013-02-15 20:53:17 +01:00
|
|
|
if (result.block_cache == nullptr && !result.no_block_cache) {
|
2011-04-12 21:38:58 +02:00
|
|
|
result.block_cache = NewLRUCache(8 << 20);
|
|
|
|
}
|
2013-01-24 19:54:26 +01:00
|
|
|
result.compression_per_level = src.compression_per_level;
|
2013-05-15 19:34:02 +02:00
|
|
|
if (result.block_size_deviation < 0 || result.block_size_deviation > 100) {
|
|
|
|
result.block_size_deviation = 0;
|
|
|
|
}
|
2013-06-09 05:15:10 +02:00
|
|
|
if (result.max_mem_compaction_level >= result.num_levels) {
|
|
|
|
result.max_mem_compaction_level = result.num_levels - 1;
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBImpl::DBImpl(const Options& options, const std::string& dbname)
|
|
|
|
: env_(options.env),
|
2012-11-06 04:18:49 +01:00
|
|
|
dbname_(dbname),
|
2011-03-18 23:37:00 +01:00
|
|
|
internal_comparator_(options.comparator),
|
2012-04-17 17:36:46 +02:00
|
|
|
options_(SanitizeOptions(
|
|
|
|
dbname, &internal_comparator_, &internal_filter_policy_, options)),
|
2012-11-06 04:18:49 +01:00
|
|
|
internal_filter_policy_(options.filter_policy),
|
2011-03-18 23:37:00 +01:00
|
|
|
owns_info_log_(options_.info_log != options.info_log),
|
2013-02-15 20:53:17 +01:00
|
|
|
db_lock_(nullptr),
|
2013-06-01 01:30:17 +02:00
|
|
|
mutex_(options.use_adaptive_mutex),
|
2013-02-15 20:53:17 +01:00
|
|
|
shutting_down_(nullptr),
|
2011-03-18 23:37:00 +01:00
|
|
|
bg_cv_(&mutex_),
|
2012-10-19 23:00:53 +02:00
|
|
|
mem_(new MemTable(internal_comparator_, NumberLevels())),
|
2011-06-22 04:36:45 +02:00
|
|
|
logfile_number_(0),
|
2013-03-28 23:19:28 +01:00
|
|
|
tmp_batch_(),
|
2012-10-19 23:00:53 +02:00
|
|
|
bg_compaction_scheduled_(0),
|
2012-08-27 09:50:26 +02:00
|
|
|
bg_logstats_scheduled_(false),
|
2013-02-15 20:53:17 +01:00
|
|
|
manual_compaction_(nullptr),
|
|
|
|
logger_(nullptr),
|
2012-10-16 17:53:46 +02:00
|
|
|
disable_delete_obsolete_files_(false),
|
2012-10-19 23:00:53 +02:00
|
|
|
delete_obsolete_files_last_run_(0),
|
2013-05-06 20:41:01 +02:00
|
|
|
purge_wal_files_last_run_(0),
|
2013-05-11 00:21:04 +02:00
|
|
|
last_stats_dump_time_microsec_(0),
|
2012-10-23 19:34:09 +02:00
|
|
|
stall_level0_slowdown_(0),
|
|
|
|
stall_memtable_compaction_(0),
|
|
|
|
stall_level0_num_files_(0),
|
2012-10-26 17:57:56 +02:00
|
|
|
started_at_(options.env->NowMicros()),
|
2013-02-19 07:32:07 +01:00
|
|
|
flush_on_destroy_(false),
|
2013-03-28 23:19:28 +01:00
|
|
|
stats_(options.num_levels),
|
2013-03-04 19:44:04 +01:00
|
|
|
delayed_writes_(0),
|
2013-03-15 01:00:04 +01:00
|
|
|
last_flushed_sequence_(0),
|
|
|
|
storage_options_(options) {
|
2013-03-04 19:44:04 +01:00
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
mem_->Ref();
|
2011-04-12 21:38:58 +02:00
|
|
|
|
2012-09-06 02:44:13 +02:00
|
|
|
env_->GetAbsolutePath(dbname, &db_absolute_path_);
|
2013-03-02 21:56:04 +01:00
|
|
|
|
|
|
|
stall_leveln_slowdown_.resize(options.num_levels);
|
|
|
|
for (int i = 0; i < options.num_levels; ++i)
|
|
|
|
stall_leveln_slowdown_[i] = 0;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Reserve ten files or so for other uses and give the rest to TableCache.
|
2012-08-22 20:43:53 +02:00
|
|
|
const int table_cache_size = options_.max_open_files - 10;
|
2013-03-15 01:00:04 +01:00
|
|
|
table_cache_.reset(new TableCache(dbname_, &options_,
|
|
|
|
storage_options_, table_cache_size));
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2013-03-15 01:00:04 +01:00
|
|
|
versions_.reset(new VersionSet(dbname_, &options_, storage_options_,
|
|
|
|
table_cache_.get(), &internal_comparator_));
|
2012-08-15 00:20:36 +02:00
|
|
|
|
2013-01-20 11:07:13 +01:00
|
|
|
dumpLeveldbBuildVersion(options_.info_log.get());
|
|
|
|
options_.Dump(options_.info_log.get());
|
2012-08-22 20:43:53 +02:00
|
|
|
|
2012-08-15 00:20:36 +02:00
|
|
|
#ifdef USE_SCRIBE
|
2013-03-28 23:19:28 +01:00
|
|
|
logger_.reset(new ScribeLogger("localhost", 1456));
|
2012-08-15 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
char name[100];
|
2012-09-12 18:54:22 +02:00
|
|
|
Status st = env_->GetHostName(name, 100L);
|
2012-08-15 00:20:36 +02:00
|
|
|
if(st.ok()) {
|
|
|
|
host_name_ = name;
|
|
|
|
} else {
|
|
|
|
Log(options_.info_log, "Can't get hostname, use localhost as host name.");
|
|
|
|
host_name_ = "localhost";
|
|
|
|
}
|
|
|
|
last_log_ts = 0;
|
2012-11-26 22:56:45 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
DBImpl::~DBImpl() {
|
|
|
|
// Wait for background work to finish
|
2013-06-11 23:23:58 +02:00
|
|
|
if (flush_on_destroy_ && mem_->GetFirstSequenceNumber() != 0) {
|
2012-11-06 20:21:57 +01:00
|
|
|
FlushMemTable(FlushOptions());
|
|
|
|
}
|
2012-11-09 03:45:19 +01:00
|
|
|
mutex_.Lock();
|
2013-02-15 20:53:17 +01:00
|
|
|
shutting_down_.Release_Store(this); // Any non-nullptr value is ok
|
2012-08-27 09:50:26 +02:00
|
|
|
while (bg_compaction_scheduled_ || bg_logstats_scheduled_) {
|
2011-06-07 16:40:26 +02:00
|
|
|
bg_cv_.Wait();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
mutex_.Unlock();
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (db_lock_ != nullptr) {
|
2011-03-18 23:37:00 +01:00
|
|
|
env_->UnlockFile(db_lock_);
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (mem_ != nullptr) mem_->Unref();
|
2012-10-19 23:00:53 +02:00
|
|
|
imm_.UnrefAll();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-11-29 01:42:36 +01:00
|
|
|
// Do not flush and close database elegantly. Simulate a crash.
|
2012-11-17 00:28:14 +01:00
|
|
|
void DBImpl::TEST_Destroy_DBImpl() {
|
|
|
|
// ensure that no new memtable flushes can occur
|
|
|
|
flush_on_destroy_ = false;
|
|
|
|
|
|
|
|
// wait till all background compactions are done.
|
|
|
|
mutex_.Lock();
|
|
|
|
while (bg_compaction_scheduled_ || bg_logstats_scheduled_) {
|
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prevent new compactions from occuring.
|
|
|
|
const int LargeNumber = 10000000;
|
|
|
|
bg_compaction_scheduled_ += LargeNumber;
|
|
|
|
mutex_.Unlock();
|
|
|
|
|
|
|
|
// force release the lock file.
|
2013-02-15 20:53:17 +01:00
|
|
|
if (db_lock_ != nullptr) {
|
2012-11-17 00:28:14 +01:00
|
|
|
env_->UnlockFile(db_lock_);
|
|
|
|
}
|
2013-01-20 11:07:13 +01:00
|
|
|
|
|
|
|
log_.reset();
|
|
|
|
versions_.reset();
|
|
|
|
table_cache_.reset();
|
2012-11-17 00:28:14 +01:00
|
|
|
}
|
|
|
|
|
2013-01-11 02:18:50 +01:00
|
|
|
uint64_t DBImpl::TEST_Current_Manifest_FileNo() {
|
|
|
|
return versions_->ManifestFileNumber();
|
|
|
|
}
|
2012-11-17 00:28:14 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DBImpl::NewDB() {
|
2012-06-23 04:30:03 +02:00
|
|
|
VersionEdit new_db(NumberLevels());
|
2011-03-18 23:37:00 +01:00
|
|
|
new_db.SetComparatorName(user_comparator()->Name());
|
2011-04-12 21:38:58 +02:00
|
|
|
new_db.SetLogNumber(0);
|
2011-03-18 23:37:00 +01:00
|
|
|
new_db.SetNextFile(2);
|
|
|
|
new_db.SetLastSequence(0);
|
|
|
|
|
|
|
|
const std::string manifest = DescriptorFileName(dbname_, 1);
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<WritableFile> file;
|
2013-03-15 01:00:04 +01:00
|
|
|
Status s = env_->NewWritableFile(manifest, &file, storage_options_);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
2013-01-15 23:05:42 +01:00
|
|
|
file->SetPreallocationBlockSize(options_.manifest_preallocation_size);
|
2011-03-18 23:37:00 +01:00
|
|
|
{
|
2013-01-20 11:07:13 +01:00
|
|
|
log::Writer log(std::move(file));
|
2011-03-18 23:37:00 +01:00
|
|
|
std::string record;
|
|
|
|
new_db.EncodeTo(&record);
|
|
|
|
s = log.AddRecord(record);
|
|
|
|
}
|
|
|
|
if (s.ok()) {
|
|
|
|
// Make "CURRENT" file that points to the new manifest file.
|
|
|
|
s = SetCurrentFile(env_, dbname_, 1);
|
|
|
|
} else {
|
|
|
|
env_->DeleteFile(manifest);
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::MaybeIgnoreError(Status* s) const {
|
|
|
|
if (s->ok() || options_.paranoid_checks) {
|
|
|
|
// No change needed
|
|
|
|
} else {
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Ignoring error %s", s->ToString().c_str());
|
2011-03-18 23:37:00 +01:00
|
|
|
*s = Status::OK();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-26 22:56:45 +01:00
|
|
|
const Status DBImpl::CreateArchivalDirectory() {
|
|
|
|
if (options_.WAL_ttl_seconds > 0) {
|
2012-12-08 01:30:22 +01:00
|
|
|
std::string archivalPath = ArchivalDirectory(dbname_);
|
2012-11-26 22:56:45 +01:00
|
|
|
return env_->CreateDirIfMissing(archivalPath);
|
|
|
|
}
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
2013-05-28 21:35:43 +02:00
|
|
|
void DBImpl::PrintStatistics() {
|
|
|
|
auto dbstats = options_.statistics;
|
|
|
|
if (dbstats) {
|
|
|
|
Log(options_.info_log,
|
2013-06-19 05:28:41 +02:00
|
|
|
"STATISTCS:\n %s",
|
|
|
|
dbstats->ToString().c_str());
|
2013-05-28 21:35:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-11 00:21:04 +02:00
|
|
|
void DBImpl::MaybeDumpStats() {
|
2013-05-24 21:52:45 +02:00
|
|
|
if (options_.stats_dump_period_sec == 0) return;
|
|
|
|
|
|
|
|
const uint64_t now_micros = env_->NowMicros();
|
|
|
|
|
|
|
|
if (last_stats_dump_time_microsec_ +
|
|
|
|
options_.stats_dump_period_sec * 1000000
|
|
|
|
<= now_micros) {
|
|
|
|
// Multiple threads could race in here simultaneously.
|
|
|
|
// However, the last one will update last_stats_dump_time_microsec_
|
|
|
|
// atomically. We could see more than one dump during one dump
|
|
|
|
// period in rare cases.
|
|
|
|
last_stats_dump_time_microsec_ = now_micros;
|
|
|
|
std::string stats;
|
|
|
|
GetProperty("leveldb.stats", &stats);
|
|
|
|
Log(options_.info_log, "%s", stats.c_str());
|
2013-05-28 21:35:43 +02:00
|
|
|
PrintStatistics();
|
2013-05-11 00:21:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
// Returns the list of live files in 'live' and the list
|
|
|
|
// of all files in the filesystem in 'allfiles'.
|
|
|
|
void DBImpl::FindObsoleteFiles(DeletionState& deletion_state) {
|
|
|
|
mutex_.AssertHeld();
|
|
|
|
|
2012-09-15 02:11:35 +02:00
|
|
|
// if deletion is disabled, do nothing
|
|
|
|
if (disable_delete_obsolete_files_) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-16 17:53:46 +02:00
|
|
|
// This method is costly when the number of files is large.
|
|
|
|
// Do not allow it to trigger more often than once in
|
|
|
|
// delete_obsolete_files_period_micros.
|
|
|
|
if (options_.delete_obsolete_files_period_micros != 0) {
|
|
|
|
const uint64_t now_micros = env_->NowMicros();
|
2012-11-06 20:21:57 +01:00
|
|
|
if (delete_obsolete_files_last_run_ +
|
2012-10-16 17:53:46 +02:00
|
|
|
options_.delete_obsolete_files_period_micros > now_micros) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
delete_obsolete_files_last_run_ = now_micros;
|
|
|
|
}
|
|
|
|
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
// Make a list of all of the live files; set is slow, should not
|
|
|
|
// be used.
|
|
|
|
deletion_state.live.assign(pending_outputs_.begin(),
|
|
|
|
pending_outputs_.end());
|
2012-10-21 10:49:48 +02:00
|
|
|
versions_->AddLiveFiles(&deletion_state.live);
|
|
|
|
|
|
|
|
// set of all files in the directory
|
|
|
|
env_->GetChildren(dbname_, &deletion_state.allfiles); // Ignore errors
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
// store the current filenum, lognum, etc
|
|
|
|
deletion_state.filenumber = versions_->ManifestFileNumber();
|
|
|
|
deletion_state.lognumber = versions_->LogNumber();
|
|
|
|
deletion_state.prevlognumber = versions_->PrevLogNumber();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Diffs the files listed in filenames and those that do not
|
|
|
|
// belong to live files are posibly removed. If the removed file
|
|
|
|
// is a sst file, then it returns the file number in files_to_evict.
|
|
|
|
// It is not necesary to hold the mutex when invoking this method.
|
|
|
|
void DBImpl::PurgeObsoleteFiles(DeletionState& state) {
|
2011-03-18 23:37:00 +01:00
|
|
|
uint64_t number;
|
|
|
|
FileType type;
|
2012-09-06 02:44:13 +02:00
|
|
|
std::vector<std::string> old_log_files;
|
2012-11-26 22:56:45 +01:00
|
|
|
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
// Now, convert live list to an unordered set, WITHOUT mutex held;
|
|
|
|
// set is slow.
|
|
|
|
std::unordered_set<uint64_t> live_set(state.live.begin(),
|
|
|
|
state.live.end());
|
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
for (size_t i = 0; i < state.allfiles.size(); i++) {
|
|
|
|
if (ParseFileName(state.allfiles[i], &number, &type)) {
|
2011-03-18 23:37:00 +01:00
|
|
|
bool keep = true;
|
|
|
|
switch (type) {
|
|
|
|
case kLogFile:
|
2012-10-21 10:49:48 +02:00
|
|
|
keep = ((number >= state.lognumber) ||
|
|
|
|
(number == state.prevlognumber));
|
2011-03-18 23:37:00 +01:00
|
|
|
break;
|
|
|
|
case kDescriptorFile:
|
|
|
|
// Keep my manifest file, and any newer incarnations'
|
|
|
|
// (in case there is a race that allows other incarnations)
|
2012-10-21 10:49:48 +02:00
|
|
|
keep = (number >= state.filenumber);
|
2011-03-18 23:37:00 +01:00
|
|
|
break;
|
|
|
|
case kTableFile:
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
keep = (live_set.find(number) != live_set.end());
|
2011-03-18 23:37:00 +01:00
|
|
|
break;
|
|
|
|
case kTempFile:
|
|
|
|
// Any temp files that are currently being written to must
|
|
|
|
// be recorded in pending_outputs_, which is inserted into "live"
|
[RocksDB] [Performance] Speed up FindObsoleteFiles
Summary:
FindObsoleteFiles was slow, holding the single big lock, resulted in bad p99 behavior.
Didn't profile anything, but several things could be improved:
1. VersionSet::AddLiveFiles works with std::set, which is by itself slow (a tree).
You also don't know how many dynamic allocations occur just for building up this tree.
switched to std::vector, also added logic to pre-calculate total size and do just one allocation
2. Don't see why env_->GetChildren() needs to be mutex proteced, moved to PurgeObsoleteFiles where
mutex could be unlocked.
3. switched std::set to std:unordered_set, the conversion from vector is also inside PurgeObsoleteFiles
I have a feeling this should pretty much fix it.
Test Plan: make check; db_stress
Reviewers: dhruba, heyongqiang, MarkCallaghan
Reviewed By: dhruba
CC: leveldb, zshao
Differential Revision: https://reviews.facebook.net/D10197
2013-04-12 01:49:53 +02:00
|
|
|
keep = (live_set.find(number) != live_set.end());
|
2011-03-18 23:37:00 +01:00
|
|
|
break;
|
2012-08-18 01:06:05 +02:00
|
|
|
case kInfoLogFile:
|
|
|
|
keep = true;
|
|
|
|
if (number != 0) {
|
2012-10-21 10:49:48 +02:00
|
|
|
old_log_files.push_back(state.allfiles[i]);
|
2012-08-18 01:06:05 +02:00
|
|
|
}
|
|
|
|
break;
|
2011-03-18 23:37:00 +01:00
|
|
|
case kCurrentFile:
|
|
|
|
case kDBLockFile:
|
2012-12-17 20:26:59 +01:00
|
|
|
case kMetaDatabase:
|
2011-03-18 23:37:00 +01:00
|
|
|
keep = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!keep) {
|
|
|
|
if (type == kTableFile) {
|
2012-10-21 10:49:48 +02:00
|
|
|
// record the files to be evicted from the cache
|
|
|
|
state.files_to_evict.push_back(number);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2013-05-06 20:41:01 +02:00
|
|
|
Log(options_.info_log, "Delete type=%d #%lu", int(type), number);
|
2012-11-26 22:56:45 +01:00
|
|
|
if (type == kLogFile && options_.WAL_ttl_seconds > 0) {
|
2013-05-06 20:41:01 +02:00
|
|
|
Status st = env_->RenameFile(
|
|
|
|
LogFileName(dbname_, number),
|
|
|
|
ArchivedLogFileName(dbname_, number)
|
|
|
|
);
|
|
|
|
|
2012-11-26 22:56:45 +01:00
|
|
|
if (!st.ok()) {
|
2013-05-06 20:41:01 +02:00
|
|
|
Log(
|
|
|
|
options_.info_log, "RenameFile type=%d #%lu FAILED",
|
2012-08-23 04:15:06 +02:00
|
|
|
int(type),
|
2013-05-06 20:41:01 +02:00
|
|
|
number
|
|
|
|
);
|
2012-11-26 22:56:45 +01:00
|
|
|
}
|
|
|
|
} else {
|
2012-12-08 01:30:22 +01:00
|
|
|
Status st = env_->DeleteFile(dbname_ + "/" + state.allfiles[i]);
|
2012-11-26 22:56:45 +01:00
|
|
|
if(!st.ok()) {
|
|
|
|
Log(options_.info_log, "Delete type=%d #%lld FAILED\n",
|
|
|
|
int(type),
|
|
|
|
static_cast<unsigned long long>(number));
|
|
|
|
}
|
2012-08-23 04:15:06 +02:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-18 01:06:05 +02:00
|
|
|
|
|
|
|
// Delete old log files.
|
2013-02-05 04:42:40 +01:00
|
|
|
size_t old_log_file_count = old_log_files.size();
|
|
|
|
// NOTE: Currently we only support log purge when options_.db_log_dir is
|
|
|
|
// located in `dbname` directory.
|
|
|
|
if (old_log_file_count >= options_.keep_log_file_num &&
|
|
|
|
options_.db_log_dir.empty()) {
|
2012-09-06 02:44:13 +02:00
|
|
|
std::sort(old_log_files.begin(), old_log_files.end());
|
2013-02-05 04:42:40 +01:00
|
|
|
size_t end = old_log_file_count - options_.keep_log_file_num;
|
2013-03-15 02:32:01 +01:00
|
|
|
for (unsigned int i = 0; i <= end; i++) {
|
2012-09-06 02:44:13 +02:00
|
|
|
std::string& to_delete = old_log_files.at(i);
|
2012-10-21 10:49:48 +02:00
|
|
|
// Log(options_.info_log, "Delete type=%d %s\n",
|
|
|
|
// int(kInfoLogFile), to_delete.c_str());
|
2012-08-18 01:06:05 +02:00
|
|
|
env_->DeleteFile(dbname_ + "/" + to_delete);
|
|
|
|
}
|
|
|
|
}
|
2013-05-06 20:41:01 +02:00
|
|
|
PurgeObsoleteWALFiles();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
void DBImpl::EvictObsoleteFiles(DeletionState& state) {
|
|
|
|
for (unsigned int i = 0; i < state.files_to_evict.size(); i++) {
|
|
|
|
table_cache_->Evict(state.files_to_evict[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::DeleteObsoleteFiles() {
|
|
|
|
mutex_.AssertHeld();
|
|
|
|
DeletionState deletion_state;
|
|
|
|
FindObsoleteFiles(deletion_state);
|
|
|
|
PurgeObsoleteFiles(deletion_state);
|
|
|
|
EvictObsoleteFiles(deletion_state);
|
2012-11-26 22:56:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::PurgeObsoleteWALFiles() {
|
2013-05-06 20:41:01 +02:00
|
|
|
int64_t current_time;
|
|
|
|
Status s = env_->GetCurrentTime(¤t_time);
|
|
|
|
uint64_t now_micros = static_cast<uint64_t>(current_time);
|
|
|
|
assert(s.ok());
|
|
|
|
|
2012-11-26 22:56:45 +01:00
|
|
|
if (options_.WAL_ttl_seconds != ULONG_MAX && options_.WAL_ttl_seconds > 0) {
|
2013-05-06 20:41:01 +02:00
|
|
|
if (purge_wal_files_last_run_ + options_.WAL_ttl_seconds > now_micros) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
std::vector<std::string> wal_files;
|
|
|
|
std::string archival_dir = ArchivalDirectory(dbname_);
|
|
|
|
env_->GetChildren(archival_dir, &wal_files);
|
|
|
|
for (const auto& f : wal_files) {
|
|
|
|
uint64_t file_m_time;
|
|
|
|
const std::string file_path = archival_dir + "/" + f;
|
|
|
|
const Status s = env_->GetFileModificationTime(file_path, &file_m_time);
|
|
|
|
if (s.ok() && (now_micros - file_m_time > options_.WAL_ttl_seconds)) {
|
|
|
|
Status status = env_->DeleteFile(file_path);
|
|
|
|
if (!status.ok()) {
|
|
|
|
Log(options_.info_log,
|
|
|
|
"Failed Deleting a WAL file Error : i%s",
|
|
|
|
status.ToString().c_str());
|
2012-11-26 22:56:45 +01:00
|
|
|
}
|
2013-03-29 02:01:06 +01:00
|
|
|
} // Ignore errors.
|
2012-11-26 22:56:45 +01:00
|
|
|
}
|
|
|
|
}
|
2013-05-06 20:41:01 +02:00
|
|
|
purge_wal_files_last_run_ = now_micros;
|
2012-10-21 10:49:48 +02:00
|
|
|
}
|
|
|
|
|
2012-12-18 22:05:39 +01:00
|
|
|
// If externalTable is set, then apply recovered transactions
|
|
|
|
// to that table. This is used for readonly mode.
|
|
|
|
Status DBImpl::Recover(VersionEdit* edit, MemTable* external_table,
|
2012-11-06 04:18:49 +01:00
|
|
|
bool error_if_log_file_exist) {
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.AssertHeld();
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(db_lock_ == nullptr);
|
2012-12-18 22:05:39 +01:00
|
|
|
if (!external_table) {
|
2013-01-07 19:11:18 +01:00
|
|
|
// We call CreateDirIfMissing() as the directory may already exist (if we
|
|
|
|
// are reopening a DB), when this happens we don't want creating the
|
|
|
|
// directory to cause an error. However, we need to check if creating the
|
|
|
|
// directory fails or else we may get an obscure message about the lock
|
|
|
|
// file not existing. One real-world example of this occurring is if
|
|
|
|
// env->CreateDirIfMissing() doesn't create intermediate directories, e.g.
|
|
|
|
// when dbname_ is "dir/db" but when "dir" doesn't exist.
|
|
|
|
Status s = env_->CreateDirIfMissing(dbname_);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = env_->LockFile(LockFileName(dbname_), &db_lock_);
|
2012-12-17 06:01:02 +01:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-12-17 06:01:02 +01:00
|
|
|
if (!env_->FileExists(CurrentFileName(dbname_))) {
|
|
|
|
if (options_.create_if_missing) {
|
2013-03-21 23:59:47 +01:00
|
|
|
// TODO: add merge_operator name check
|
2012-12-17 06:01:02 +01:00
|
|
|
s = NewDB();
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return Status::InvalidArgument(
|
|
|
|
dbname_, "does not exist (create_if_missing is false)");
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
} else {
|
2012-12-17 06:01:02 +01:00
|
|
|
if (options_.error_if_exists) {
|
|
|
|
return Status::InvalidArgument(
|
|
|
|
dbname_, "exists (error_if_exists is true)");
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 06:01:02 +01:00
|
|
|
Status s = versions_->Recover();
|
2011-03-18 23:37:00 +01:00
|
|
|
if (s.ok()) {
|
|
|
|
SequenceNumber max_sequence(0);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
|
|
|
// Recover from all newer log files than the ones named in the
|
|
|
|
// descriptor (new log files may have been added by the previous
|
|
|
|
// incarnation without registering them in the descriptor).
|
|
|
|
//
|
|
|
|
// Note that PrevLogNumber() is no longer used, but we pay
|
|
|
|
// attention to it in case we are recovering a database
|
|
|
|
// produced by an older version of leveldb.
|
|
|
|
const uint64_t min_log = versions_->LogNumber();
|
|
|
|
const uint64_t prev_log = versions_->PrevLogNumber();
|
|
|
|
std::vector<std::string> filenames;
|
|
|
|
s = env_->GetChildren(dbname_, &filenames);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
2011-06-22 04:36:45 +02:00
|
|
|
uint64_t number;
|
|
|
|
FileType type;
|
|
|
|
std::vector<uint64_t> logs;
|
|
|
|
for (size_t i = 0; i < filenames.size(); i++) {
|
|
|
|
if (ParseFileName(filenames[i], &number, &type)
|
|
|
|
&& type == kLogFile
|
|
|
|
&& ((number >= min_log) || (number == prev_log))) {
|
|
|
|
logs.push_back(number);
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2012-11-06 04:18:49 +01:00
|
|
|
if (logs.size() > 0 && error_if_log_file_exist) {
|
|
|
|
return Status::Corruption(""
|
|
|
|
"The db was opened in readonly mode with error_if_log_file_exist"
|
|
|
|
"flag but a log file already exists");
|
|
|
|
}
|
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
// Recover in the order in which the logs were generated
|
|
|
|
std::sort(logs.begin(), logs.end());
|
|
|
|
for (size_t i = 0; i < logs.size(); i++) {
|
2012-12-18 22:05:39 +01:00
|
|
|
s = RecoverLogFile(logs[i], edit, &max_sequence, external_table);
|
2011-09-01 21:08:02 +02:00
|
|
|
// The previous incarnation may not have written any MANIFEST
|
|
|
|
// records after allocating this log number. So we manually
|
|
|
|
// update the file number allocation counter in VersionSet.
|
|
|
|
versions_->MarkFileNumberUsed(logs[i]);
|
2011-06-22 04:36:45 +02:00
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
if (s.ok()) {
|
2011-04-12 21:38:58 +02:00
|
|
|
if (versions_->LastSequence() < max_sequence) {
|
|
|
|
versions_->SetLastSequence(max_sequence);
|
2013-04-03 02:18:27 +02:00
|
|
|
last_flushed_sequence_ = max_sequence;
|
|
|
|
} else {
|
|
|
|
last_flushed_sequence_ = versions_->LastSequence();
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::RecoverLogFile(uint64_t log_number,
|
|
|
|
VersionEdit* edit,
|
2012-12-18 22:05:39 +01:00
|
|
|
SequenceNumber* max_sequence,
|
|
|
|
MemTable* external_table) {
|
2011-03-18 23:37:00 +01:00
|
|
|
struct LogReporter : public log::Reader::Reporter {
|
|
|
|
Env* env;
|
2011-07-21 04:40:18 +02:00
|
|
|
Logger* info_log;
|
2011-03-18 23:37:00 +01:00
|
|
|
const char* fname;
|
2013-05-21 20:53:33 +02:00
|
|
|
Status* status; // nullptr if options_.paranoid_checks==false or
|
|
|
|
// options_.skip_log_error_on_recovery==true
|
2011-03-18 23:37:00 +01:00
|
|
|
virtual void Corruption(size_t bytes, const Status& s) {
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(info_log, "%s%s: dropping %d bytes; %s",
|
2013-02-15 20:53:17 +01:00
|
|
|
(this->status == nullptr ? "(ignoring error) " : ""),
|
2011-03-18 23:37:00 +01:00
|
|
|
fname, static_cast<int>(bytes), s.ToString().c_str());
|
2013-02-15 20:53:17 +01:00
|
|
|
if (this->status != nullptr && this->status->ok()) *this->status = s;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
mutex_.AssertHeld();
|
|
|
|
|
|
|
|
// Open the log file
|
|
|
|
std::string fname = LogFileName(dbname_, log_number);
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<SequentialFile> file;
|
2013-03-15 01:00:04 +01:00
|
|
|
Status status = env_->NewSequentialFile(fname, &file, storage_options_);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!status.ok()) {
|
|
|
|
MaybeIgnoreError(&status);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the log reader.
|
|
|
|
LogReporter reporter;
|
|
|
|
reporter.env = env_;
|
2013-01-20 11:07:13 +01:00
|
|
|
reporter.info_log = options_.info_log.get();
|
2011-03-18 23:37:00 +01:00
|
|
|
reporter.fname = fname.c_str();
|
2013-05-21 20:53:33 +02:00
|
|
|
reporter.status = (options_.paranoid_checks &&
|
|
|
|
!options_.skip_log_error_on_recovery ? &status : nullptr);
|
2011-03-18 23:37:00 +01:00
|
|
|
// We intentially make log::Reader do checksumming even if
|
|
|
|
// paranoid_checks==false so that corruptions cause entire commits
|
|
|
|
// to be skipped instead of propagating bad information (like overly
|
|
|
|
// large sequence numbers).
|
2013-01-20 11:07:13 +01:00
|
|
|
log::Reader reader(std::move(file), &reporter, true/*checksum*/,
|
2011-05-21 04:17:43 +02:00
|
|
|
0/*initial_offset*/);
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Recovering log #%llu",
|
2011-03-18 23:37:00 +01:00
|
|
|
(unsigned long long) log_number);
|
|
|
|
|
|
|
|
// Read all the records and add to a memtable
|
|
|
|
std::string scratch;
|
|
|
|
Slice record;
|
|
|
|
WriteBatch batch;
|
2013-02-15 20:53:17 +01:00
|
|
|
MemTable* mem = nullptr;
|
2012-12-18 22:05:39 +01:00
|
|
|
if (external_table) {
|
|
|
|
mem = external_table;
|
|
|
|
}
|
2013-05-21 20:53:33 +02:00
|
|
|
while (reader.ReadRecord(&record, &scratch) && status.ok()) {
|
2011-03-18 23:37:00 +01:00
|
|
|
if (record.size() < 12) {
|
|
|
|
reporter.Corruption(
|
|
|
|
record.size(), Status::Corruption("log record too small"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
WriteBatchInternal::SetContents(&batch, record);
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (mem == nullptr) {
|
2012-10-19 23:00:53 +02:00
|
|
|
mem = new MemTable(internal_comparator_, NumberLevels());
|
2011-05-21 04:17:43 +02:00
|
|
|
mem->Ref();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
status = WriteBatchInternal::InsertInto(&batch, mem);
|
|
|
|
MaybeIgnoreError(&status);
|
|
|
|
if (!status.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
const SequenceNumber last_seq =
|
|
|
|
WriteBatchInternal::Sequence(&batch) +
|
|
|
|
WriteBatchInternal::Count(&batch) - 1;
|
|
|
|
if (last_seq > *max_sequence) {
|
|
|
|
*max_sequence = last_seq;
|
|
|
|
}
|
|
|
|
|
2012-12-18 22:05:39 +01:00
|
|
|
if (!external_table &&
|
|
|
|
mem->ApproximateMemoryUsage() > options_.write_buffer_size) {
|
2012-10-19 23:00:53 +02:00
|
|
|
status = WriteLevel0TableForRecovery(mem, edit);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!status.ok()) {
|
|
|
|
// Reflect errors immediately so that conditions like full
|
|
|
|
// file-systems cause the DB::Open() to fail.
|
|
|
|
break;
|
|
|
|
}
|
2011-05-21 04:17:43 +02:00
|
|
|
mem->Unref();
|
2013-02-15 20:53:17 +01:00
|
|
|
mem = nullptr;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (status.ok() && mem != nullptr && !external_table) {
|
2012-10-19 23:00:53 +02:00
|
|
|
status = WriteLevel0TableForRecovery(mem, edit);
|
2011-03-18 23:37:00 +01:00
|
|
|
// Reflect errors immediately so that conditions like full
|
|
|
|
// file-systems cause the DB::Open() to fail.
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (mem != nullptr && !external_table) mem->Unref();
|
2011-03-18 23:37:00 +01:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
Status DBImpl::WriteLevel0TableForRecovery(MemTable* mem, VersionEdit* edit) {
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.AssertHeld();
|
2011-04-12 21:38:58 +02:00
|
|
|
const uint64_t start_micros = env_->NowMicros();
|
2011-03-18 23:37:00 +01:00
|
|
|
FileMetaData meta;
|
|
|
|
meta.number = versions_->NewFileNumber();
|
|
|
|
pending_outputs_.insert(meta.number);
|
|
|
|
Iterator* iter = mem->NewIterator();
|
2013-02-28 23:09:30 +01:00
|
|
|
const SequenceNumber newest_snapshot = snapshots_.GetNewest();
|
|
|
|
const SequenceNumber earliest_seqno_in_memtable =
|
|
|
|
mem->GetFirstSequenceNumber();
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Level-0 table #%llu: started",
|
2011-03-18 23:37:00 +01:00
|
|
|
(unsigned long long) meta.number);
|
2011-04-12 21:38:58 +02:00
|
|
|
|
|
|
|
Status s;
|
|
|
|
{
|
|
|
|
mutex_.Unlock();
|
2013-03-15 01:00:04 +01:00
|
|
|
s = BuildTable(dbname_, env_, options_, storage_options_,
|
|
|
|
table_cache_.get(), iter, &meta,
|
2013-02-28 23:09:30 +01:00
|
|
|
user_comparator(), newest_snapshot,
|
|
|
|
earliest_seqno_in_memtable);
|
2011-04-12 21:38:58 +02:00
|
|
|
mutex_.Lock();
|
|
|
|
}
|
|
|
|
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Level-0 table #%llu: %lld bytes %s",
|
2011-03-18 23:37:00 +01:00
|
|
|
(unsigned long long) meta.number,
|
|
|
|
(unsigned long long) meta.file_size,
|
|
|
|
s.ToString().c_str());
|
|
|
|
delete iter;
|
2011-04-12 21:38:58 +02:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
pending_outputs_.erase(meta.number);
|
2011-06-22 04:36:45 +02:00
|
|
|
|
|
|
|
// Note that if file_size is zero, the file has been deleted and
|
|
|
|
// should not be added to the manifest.
|
|
|
|
int level = 0;
|
|
|
|
if (s.ok() && meta.file_size > 0) {
|
|
|
|
edit->AddFile(level, meta.number, meta.file_size,
|
2013-06-14 07:09:08 +02:00
|
|
|
meta.smallest, meta.largest,
|
|
|
|
meta.smallest_seqno, meta.largest_seqno);
|
2011-06-22 04:36:45 +02:00
|
|
|
}
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
CompactionStats stats;
|
|
|
|
stats.micros = env_->NowMicros() - start_micros;
|
|
|
|
stats.bytes_written = meta.file_size;
|
2012-10-23 19:34:09 +02:00
|
|
|
stats.files_out_levelnp1 = 1;
|
2011-06-22 04:36:45 +02:00
|
|
|
stats_[level].Add(stats);
|
2011-03-18 23:37:00 +01:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2013-06-11 23:23:58 +02:00
|
|
|
Status DBImpl::WriteLevel0Table(std::vector<MemTable*> &mems, VersionEdit* edit,
|
2012-10-19 23:00:53 +02:00
|
|
|
uint64_t* filenumber) {
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.AssertHeld();
|
2012-10-19 23:00:53 +02:00
|
|
|
const uint64_t start_micros = env_->NowMicros();
|
|
|
|
FileMetaData meta;
|
|
|
|
meta.number = versions_->NewFileNumber();
|
|
|
|
*filenumber = meta.number;
|
|
|
|
pending_outputs_.insert(meta.number);
|
2013-06-11 23:23:58 +02:00
|
|
|
|
|
|
|
std::vector<Iterator*> list;
|
|
|
|
for (MemTable* m : mems) {
|
|
|
|
list.push_back(m->NewIterator());
|
|
|
|
}
|
|
|
|
Iterator* iter = NewMergingIterator(&internal_comparator_, &list[0],
|
|
|
|
list.size());
|
2013-02-28 23:09:30 +01:00
|
|
|
const SequenceNumber newest_snapshot = snapshots_.GetNewest();
|
|
|
|
const SequenceNumber earliest_seqno_in_memtable =
|
2013-06-11 23:23:58 +02:00
|
|
|
mems[0]->GetFirstSequenceNumber();
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Level-0 flush table #%llu: started",
|
|
|
|
(unsigned long long) meta.number);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
Version* base = versions_->current();
|
2013-06-11 23:23:58 +02:00
|
|
|
base->Ref(); // it is likely that we do not need this reference
|
2012-10-19 23:00:53 +02:00
|
|
|
Status s;
|
|
|
|
{
|
|
|
|
mutex_.Unlock();
|
2013-03-15 01:00:04 +01:00
|
|
|
s = BuildTable(dbname_, env_, options_, storage_options_,
|
|
|
|
table_cache_.get(), iter, &meta,
|
2013-02-28 23:09:30 +01:00
|
|
|
user_comparator(), newest_snapshot,
|
|
|
|
earliest_seqno_in_memtable);
|
2012-10-19 23:00:53 +02:00
|
|
|
mutex_.Lock();
|
|
|
|
}
|
2011-06-22 04:36:45 +02:00
|
|
|
base->Unref();
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Level-0 flush table #%llu: %lld bytes %s",
|
|
|
|
(unsigned long long) meta.number,
|
|
|
|
(unsigned long long) meta.file_size,
|
|
|
|
s.ToString().c_str());
|
|
|
|
delete iter;
|
|
|
|
|
|
|
|
// re-acquire the most current version
|
|
|
|
base = versions_->current();
|
|
|
|
|
|
|
|
// There could be multiple threads writing to its own level-0 file.
|
|
|
|
// The pending_outputs cannot be cleared here, otherwise this newly
|
|
|
|
// created file might not be considered as a live-file by another
|
|
|
|
// compaction thread that is concurrently deleting obselete files.
|
|
|
|
// The pending_outputs can be cleared only after the new version is
|
2012-11-29 01:42:36 +01:00
|
|
|
// committed so that other threads can recognize this file as a
|
2012-10-19 23:00:53 +02:00
|
|
|
// valid one.
|
|
|
|
// pending_outputs_.erase(meta.number);
|
|
|
|
|
|
|
|
// Note that if file_size is zero, the file has been deleted and
|
|
|
|
// should not be added to the manifest.
|
|
|
|
int level = 0;
|
|
|
|
if (s.ok() && meta.file_size > 0) {
|
|
|
|
const Slice min_user_key = meta.smallest.user_key();
|
|
|
|
const Slice max_user_key = meta.largest.user_key();
|
|
|
|
// if we have more than 1 background thread, then we cannot
|
|
|
|
// insert files directly into higher levels because some other
|
|
|
|
// threads could be concurrently producing compacted files for
|
|
|
|
// that key range.
|
2013-06-14 07:09:08 +02:00
|
|
|
if (base != nullptr && options_.max_background_compactions <= 1 &&
|
|
|
|
!options_.hybrid_mode) {
|
2012-10-19 23:00:53 +02:00
|
|
|
level = base->PickLevelForMemTableOutput(min_user_key, max_user_key);
|
|
|
|
}
|
|
|
|
edit->AddFile(level, meta.number, meta.file_size,
|
2013-06-14 07:09:08 +02:00
|
|
|
meta.smallest, meta.largest,
|
|
|
|
meta.smallest_seqno, meta.largest_seqno);
|
2012-10-19 23:00:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
CompactionStats stats;
|
|
|
|
stats.micros = env_->NowMicros() - start_micros;
|
|
|
|
stats.bytes_written = meta.file_size;
|
|
|
|
stats_[level].Add(stats);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::CompactMemTable(bool* madeProgress) {
|
|
|
|
mutex_.AssertHeld();
|
|
|
|
assert(imm_.size() != 0);
|
|
|
|
|
2013-06-11 23:23:58 +02:00
|
|
|
if (!imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) {
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Memcompaction already in progress");
|
|
|
|
Status s = Status::IOError("Memcompaction already in progress");
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save the contents of the earliest memtable as a new Table
|
|
|
|
// This will release and re-acquire the mutex.
|
|
|
|
uint64_t file_number;
|
2013-06-11 23:23:58 +02:00
|
|
|
std::vector<MemTable*> mems;
|
|
|
|
imm_.PickMemtablesToFlush(&mems);
|
|
|
|
if (mems.empty()) {
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Nothing in memstore to flush");
|
|
|
|
Status s = Status::IOError("Nothing in memstore to flush");
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
// record the logfile_number_ before we release the mutex
|
2013-06-11 23:23:58 +02:00
|
|
|
MemTable* m = mems[0];
|
2012-10-19 23:00:53 +02:00
|
|
|
VersionEdit* edit = m->GetEdits();
|
|
|
|
edit->SetPrevLogNumber(0);
|
2013-06-11 23:23:58 +02:00
|
|
|
edit->SetLogNumber(m->GetLogNumber()); // Earlier logs no longer needed
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2013-06-11 23:23:58 +02:00
|
|
|
Status s = WriteLevel0Table(mems, edit, &file_number);
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2011-06-22 04:36:45 +02:00
|
|
|
if (s.ok() && shutting_down_.Acquire_Load()) {
|
2013-04-16 00:27:15 +02:00
|
|
|
s = Status::IOError(
|
|
|
|
"Database shutdown started during memtable compaction"
|
|
|
|
);
|
2011-06-22 04:36:45 +02:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
// Replace immutable memtable with the generated Table
|
2013-01-20 11:07:13 +01:00
|
|
|
s = imm_.InstallMemtableFlushResults(
|
2013-06-11 23:23:58 +02:00
|
|
|
mems, versions_.get(), s, &mutex_, options_.info_log.get(),
|
2013-01-20 11:07:13 +01:00
|
|
|
file_number, pending_outputs_);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
if (s.ok()) {
|
2012-10-19 23:00:53 +02:00
|
|
|
if (madeProgress) {
|
|
|
|
*madeProgress = 1;
|
|
|
|
}
|
2012-08-15 00:20:36 +02:00
|
|
|
MaybeScheduleLogDBDeployStats();
|
2012-10-21 10:49:48 +02:00
|
|
|
// we could have deleted obsolete files here, but it is not
|
|
|
|
// absolutely necessary because it could be also done as part
|
|
|
|
// of other background compaction
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
void DBImpl::CompactRange(const Slice* begin, const Slice* end) {
|
|
|
|
int max_level_with_files = 1;
|
|
|
|
{
|
|
|
|
MutexLock l(&mutex_);
|
|
|
|
Version* base = versions_->current();
|
2012-06-23 04:30:03 +02:00
|
|
|
for (int level = 1; level < NumberLevels(); level++) {
|
2011-10-06 01:30:28 +02:00
|
|
|
if (base->OverlapInLevel(level, begin, end)) {
|
|
|
|
max_level_with_files = level;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
TEST_CompactMemTable(); // TODO(sanjay): Skip if memtable does not overlap
|
|
|
|
for (int level = 0; level < max_level_with_files; level++) {
|
|
|
|
TEST_CompactRange(level, begin, end);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-23 04:30:03 +02:00
|
|
|
int DBImpl::NumberLevels() {
|
2012-08-15 00:20:36 +02:00
|
|
|
return options_.num_levels;
|
2012-06-23 04:30:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int DBImpl::MaxMemCompactionLevel() {
|
2012-08-15 00:20:36 +02:00
|
|
|
return options_.max_mem_compaction_level;
|
2012-06-23 04:30:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int DBImpl::Level0StopWriteTrigger() {
|
2012-08-15 00:20:36 +02:00
|
|
|
return options_.level0_stop_writes_trigger;
|
2012-06-23 04:30:03 +02:00
|
|
|
}
|
|
|
|
|
2012-07-06 20:42:09 +02:00
|
|
|
Status DBImpl::Flush(const FlushOptions& options) {
|
|
|
|
Status status = FlushMemTable(options);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-12-11 00:37:00 +01:00
|
|
|
SequenceNumber DBImpl::GetLatestSequenceNumber() {
|
|
|
|
return versions_->LastSequence();
|
|
|
|
}
|
|
|
|
|
2012-11-30 02:28:37 +01:00
|
|
|
Status DBImpl::GetUpdatesSince(SequenceNumber seq,
|
2013-01-24 19:54:26 +01:00
|
|
|
unique_ptr<TransactionLogIterator>* iter) {
|
2012-11-30 02:28:37 +01:00
|
|
|
|
|
|
|
// Get All Log Files.
|
|
|
|
// Sort Files
|
|
|
|
// Get the first entry from each file.
|
|
|
|
// Do binary search and open files and find the seq number.
|
|
|
|
|
|
|
|
std::vector<LogFile> walFiles;
|
|
|
|
// list wal files in main db dir.
|
|
|
|
Status s = ListAllWALFiles(dbname_, &walFiles, kAliveLogFile);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
// list wal files in archive dir.
|
2012-12-17 06:01:02 +01:00
|
|
|
std::string archivedir = ArchivalDirectory(dbname_);
|
|
|
|
if (env_->FileExists(archivedir)) {
|
|
|
|
s = ListAllWALFiles(archivedir, &walFiles, kArchivedLogFile);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
2012-11-30 02:28:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (walFiles.empty()) {
|
|
|
|
return Status::IOError(" NO WAL Files present in the db");
|
|
|
|
}
|
|
|
|
// std::shared_ptr would have been useful here.
|
|
|
|
|
2013-04-09 22:21:11 +02:00
|
|
|
std::unique_ptr<std::vector<LogFile>> probableWALFiles(
|
|
|
|
new std::vector<LogFile>());
|
|
|
|
s = FindProbableWALFiles(&walFiles, probableWALFiles.get(), seq);
|
2012-12-10 20:02:07 +01:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
2012-11-30 02:28:37 +01:00
|
|
|
}
|
2013-01-24 19:54:26 +01:00
|
|
|
iter->reset(
|
2013-03-04 19:44:04 +01:00
|
|
|
new TransactionLogIteratorImpl(dbname_,
|
|
|
|
&options_,
|
2013-03-15 01:00:04 +01:00
|
|
|
storage_options_,
|
2013-03-04 19:44:04 +01:00
|
|
|
seq,
|
2013-04-09 22:21:11 +02:00
|
|
|
std::move(probableWALFiles),
|
2013-03-04 19:44:04 +01:00
|
|
|
&last_flushed_sequence_));
|
|
|
|
iter->get()->Next();
|
2013-04-09 01:28:09 +02:00
|
|
|
return iter->get()->status();
|
2012-11-30 02:28:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::FindProbableWALFiles(std::vector<LogFile>* const allLogs,
|
|
|
|
std::vector<LogFile>* const result,
|
|
|
|
const SequenceNumber target) {
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(allLogs != nullptr);
|
|
|
|
assert(result != nullptr);
|
2012-11-30 02:28:37 +01:00
|
|
|
|
|
|
|
std::sort(allLogs->begin(), allLogs->end());
|
2012-12-10 20:02:07 +01:00
|
|
|
long start = 0; // signed to avoid overflow when target is < first file.
|
|
|
|
long end = static_cast<long>(allLogs->size()) - 1;
|
2012-11-30 02:28:37 +01:00
|
|
|
// Binary Search. avoid opening all files.
|
2012-12-10 20:02:07 +01:00
|
|
|
while (end >= start) {
|
|
|
|
long mid = start + (end - start) / 2; // Avoid overflow.
|
2012-11-30 02:28:37 +01:00
|
|
|
WriteBatch batch;
|
|
|
|
Status s = ReadFirstRecord(allLogs->at(mid), &batch);
|
|
|
|
if (!s.ok()) {
|
2013-03-18 22:50:59 +01:00
|
|
|
if (CheckFileExistsAndEmpty(allLogs->at(mid))) {
|
|
|
|
allLogs->erase(allLogs->begin() + mid);
|
2013-03-28 21:37:15 +01:00
|
|
|
--end;
|
2013-03-18 22:50:59 +01:00
|
|
|
continue;
|
|
|
|
}
|
2012-11-30 02:28:37 +01:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
SequenceNumber currentSeqNum = WriteBatchInternal::Sequence(&batch);
|
|
|
|
if (currentSeqNum == target) {
|
|
|
|
start = mid;
|
|
|
|
end = mid;
|
2012-12-10 20:02:07 +01:00
|
|
|
break;
|
2012-11-30 02:28:37 +01:00
|
|
|
} else if (currentSeqNum < target) {
|
2012-12-10 20:02:07 +01:00
|
|
|
start = mid + 1;
|
2012-11-30 02:28:37 +01:00
|
|
|
} else {
|
2012-12-10 20:02:07 +01:00
|
|
|
end = mid - 1;
|
2012-11-30 02:28:37 +01:00
|
|
|
}
|
|
|
|
}
|
2012-12-10 20:02:07 +01:00
|
|
|
size_t startIndex = std::max(0l, end); // end could be -ve.
|
|
|
|
for( size_t i = startIndex; i < allLogs->size(); ++i) {
|
2012-11-30 02:28:37 +01:00
|
|
|
result->push_back(allLogs->at(i));
|
|
|
|
}
|
2013-03-28 21:19:07 +01:00
|
|
|
if (result->empty()) {
|
|
|
|
return Status::IOError(
|
|
|
|
"No probable files. Check if the db contains log files");
|
|
|
|
}
|
2012-11-30 02:28:37 +01:00
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
2013-03-18 22:50:59 +01:00
|
|
|
bool DBImpl::CheckFileExistsAndEmpty(const LogFile& file) {
|
|
|
|
if (file.type == kAliveLogFile) {
|
|
|
|
const std::string fname = LogFileName(dbname_, file.logNumber);
|
|
|
|
uint64_t file_size;
|
|
|
|
Status s = env_->GetFileSize(fname, &file_size);
|
|
|
|
if (s.ok() && file_size == 0) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
const std::string fname = ArchivedLogFileName(dbname_, file.logNumber);
|
|
|
|
uint64_t file_size;
|
|
|
|
Status s = env_->GetFileSize(fname, &file_size);
|
|
|
|
if (s.ok() && file_size == 0) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-11-30 02:28:37 +01:00
|
|
|
Status DBImpl::ReadFirstRecord(const LogFile& file, WriteBatch* const result) {
|
|
|
|
|
|
|
|
if (file.type == kAliveLogFile) {
|
|
|
|
std::string fname = LogFileName(dbname_, file.logNumber);
|
|
|
|
Status status = ReadFirstLine(fname, result);
|
|
|
|
if (!status.ok()) {
|
|
|
|
// check if the file got moved to archive.
|
|
|
|
std::string archivedFile = ArchivedLogFileName(dbname_, file.logNumber);
|
|
|
|
Status s = ReadFirstLine(archivedFile, result);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return Status::IOError("Log File Has been deleted");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Status::OK();
|
|
|
|
} else if (file.type == kArchivedLogFile) {
|
|
|
|
std::string fname = ArchivedLogFileName(dbname_, file.logNumber);
|
|
|
|
Status status = ReadFirstLine(fname, result);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
return Status::NotSupported("File Type Not Known");
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::ReadFirstLine(const std::string& fname,
|
|
|
|
WriteBatch* const batch) {
|
|
|
|
struct LogReporter : public log::Reader::Reporter {
|
|
|
|
Env* env;
|
|
|
|
Logger* info_log;
|
|
|
|
const char* fname;
|
2013-02-15 20:53:17 +01:00
|
|
|
Status* status; // nullptr if options_.paranoid_checks==false
|
2012-11-30 02:28:37 +01:00
|
|
|
virtual void Corruption(size_t bytes, const Status& s) {
|
|
|
|
Log(info_log, "%s%s: dropping %d bytes; %s",
|
2013-02-15 20:53:17 +01:00
|
|
|
(this->status == nullptr ? "(ignoring error) " : ""),
|
2012-11-30 02:28:37 +01:00
|
|
|
fname, static_cast<int>(bytes), s.ToString().c_str());
|
2013-02-15 20:53:17 +01:00
|
|
|
if (this->status != nullptr && this->status->ok()) *this->status = s;
|
2012-11-30 02:28:37 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<SequentialFile> file;
|
2013-03-15 01:00:04 +01:00
|
|
|
Status status = env_->NewSequentialFile(fname, &file, storage_options_);
|
2012-11-30 02:28:37 +01:00
|
|
|
|
|
|
|
if (!status.ok()) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LogReporter reporter;
|
|
|
|
reporter.env = env_;
|
2013-01-20 11:07:13 +01:00
|
|
|
reporter.info_log = options_.info_log.get();
|
2012-11-30 02:28:37 +01:00
|
|
|
reporter.fname = fname.c_str();
|
2013-02-15 20:53:17 +01:00
|
|
|
reporter.status = (options_.paranoid_checks ? &status : nullptr);
|
2013-01-20 11:07:13 +01:00
|
|
|
log::Reader reader(std::move(file), &reporter, true/*checksum*/,
|
2012-11-30 02:28:37 +01:00
|
|
|
0/*initial_offset*/);
|
|
|
|
std::string scratch;
|
|
|
|
Slice record;
|
|
|
|
if (reader.ReadRecord(&record, &scratch) && status.ok()) {
|
|
|
|
if (record.size() < 12) {
|
|
|
|
reporter.Corruption(
|
|
|
|
record.size(), Status::Corruption("log record too small"));
|
|
|
|
return Status::IOError("Corruption noted");
|
|
|
|
// TODO read record's till the first no corrupt entry?
|
|
|
|
}
|
|
|
|
WriteBatchInternal::SetContents(batch, record);
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
return Status::IOError("Error reading from file " + fname);
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::ListAllWALFiles(const std::string& path,
|
|
|
|
std::vector<LogFile>* const logFiles,
|
|
|
|
WalFileType logType) {
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(logFiles != nullptr);
|
2012-11-30 02:28:37 +01:00
|
|
|
std::vector<std::string> allFiles;
|
|
|
|
const Status status = env_->GetChildren(path, &allFiles);
|
|
|
|
if (!status.ok()) {
|
|
|
|
return status;
|
|
|
|
}
|
2013-03-29 02:01:06 +01:00
|
|
|
for (const auto& f : allFiles) {
|
2012-11-30 02:28:37 +01:00
|
|
|
uint64_t number;
|
|
|
|
FileType type;
|
2013-03-29 02:01:06 +01:00
|
|
|
if (ParseFileName(f, &number, &type) && type == kLogFile){
|
2012-11-30 02:28:37 +01:00
|
|
|
logFiles->push_back(LogFile(number, logType));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
void DBImpl::TEST_CompactRange(int level, const Slice* begin,const Slice* end) {
|
2011-06-22 04:36:45 +02:00
|
|
|
assert(level >= 0);
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
InternalKey begin_storage, end_storage;
|
|
|
|
|
2011-06-07 16:40:26 +02:00
|
|
|
ManualCompaction manual;
|
|
|
|
manual.level = level;
|
2011-10-06 01:30:28 +02:00
|
|
|
manual.done = false;
|
2012-10-19 23:00:53 +02:00
|
|
|
manual.in_progress = false;
|
2013-02-15 20:53:17 +01:00
|
|
|
if (begin == nullptr) {
|
|
|
|
manual.begin = nullptr;
|
2011-10-06 01:30:28 +02:00
|
|
|
} else {
|
|
|
|
begin_storage = InternalKey(*begin, kMaxSequenceNumber, kValueTypeForSeek);
|
|
|
|
manual.begin = &begin_storage;
|
|
|
|
}
|
2013-02-15 20:53:17 +01:00
|
|
|
if (end == nullptr) {
|
|
|
|
manual.end = nullptr;
|
2011-10-06 01:30:28 +02:00
|
|
|
} else {
|
|
|
|
end_storage = InternalKey(*end, 0, static_cast<ValueType>(0));
|
|
|
|
manual.end = &end_storage;
|
|
|
|
}
|
|
|
|
|
|
|
|
MutexLock l(&mutex_);
|
2012-10-19 23:00:53 +02:00
|
|
|
|
2012-11-29 01:42:36 +01:00
|
|
|
// When a manual compaction arrives, temporarily throttle down
|
|
|
|
// the number of background compaction threads to 1. This is
|
|
|
|
// needed to ensure that this manual compaction can compact
|
|
|
|
// any range of keys/files. We artificialy increase
|
2012-10-19 23:00:53 +02:00
|
|
|
// bg_compaction_scheduled_ by a large number, this causes
|
|
|
|
// the system to have a single background thread. Now,
|
|
|
|
// this manual compaction can progress without stomping
|
|
|
|
// on any other concurrent compactions.
|
|
|
|
const int LargeNumber = 10000000;
|
|
|
|
const int newvalue = options_.max_background_compactions-1;
|
|
|
|
bg_compaction_scheduled_ += LargeNumber;
|
|
|
|
while (bg_compaction_scheduled_ > LargeNumber) {
|
|
|
|
Log(options_.info_log, "Manual compaction request waiting for background threads to fall below 1");
|
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
|
|
|
Log(options_.info_log, "Manual compaction starting");
|
|
|
|
|
2011-10-06 01:30:28 +02:00
|
|
|
while (!manual.done) {
|
2013-02-15 20:53:17 +01:00
|
|
|
while (manual_compaction_ != nullptr) {
|
2011-10-06 01:30:28 +02:00
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
|
|
|
manual_compaction_ = &manual;
|
2012-10-19 23:00:53 +02:00
|
|
|
if (bg_compaction_scheduled_ == LargeNumber) {
|
|
|
|
bg_compaction_scheduled_ = newvalue;
|
|
|
|
}
|
2011-10-06 01:30:28 +02:00
|
|
|
MaybeScheduleCompaction();
|
|
|
|
while (manual_compaction_ == &manual) {
|
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
2011-06-07 16:40:26 +02:00
|
|
|
}
|
2012-10-19 23:00:53 +02:00
|
|
|
assert(!manual.in_progress);
|
|
|
|
|
|
|
|
// wait till there are no background threads scheduled
|
|
|
|
bg_compaction_scheduled_ += LargeNumber;
|
|
|
|
while (bg_compaction_scheduled_ > LargeNumber + newvalue) {
|
|
|
|
Log(options_.info_log, "Manual compaction resetting background threads");
|
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
|
|
|
bg_compaction_scheduled_ = 0;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-07-06 20:42:09 +02:00
|
|
|
Status DBImpl::FlushMemTable(const FlushOptions& options) {
|
2013-02-15 20:53:17 +01:00
|
|
|
// nullptr batch means just wait for earlier writes to be done
|
|
|
|
Status s = Write(WriteOptions(), nullptr);
|
2012-07-06 20:42:09 +02:00
|
|
|
if (s.ok() && options.wait) {
|
2011-04-12 21:38:58 +02:00
|
|
|
// Wait until the compaction completes
|
2012-07-06 20:42:09 +02:00
|
|
|
s = WaitForCompactMemTable();
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
|
|
|
return s;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-07-06 20:42:09 +02:00
|
|
|
Status DBImpl::WaitForCompactMemTable() {
|
2012-08-15 00:20:36 +02:00
|
|
|
Status s;
|
|
|
|
// Wait until the compaction completes
|
|
|
|
MutexLock l(&mutex_);
|
2012-10-19 23:00:53 +02:00
|
|
|
while (imm_.size() > 0 && bg_error_.ok()) {
|
2012-08-15 00:20:36 +02:00
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
2012-10-19 23:00:53 +02:00
|
|
|
if (imm_.size() != 0) {
|
2012-08-15 00:20:36 +02:00
|
|
|
s = bg_error_;
|
|
|
|
}
|
|
|
|
return s;
|
2012-07-06 20:42:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::TEST_CompactMemTable() {
|
|
|
|
return FlushMemTable(FlushOptions());
|
|
|
|
}
|
|
|
|
|
2012-06-23 04:30:03 +02:00
|
|
|
Status DBImpl::TEST_WaitForCompactMemTable() {
|
2012-08-15 00:20:36 +02:00
|
|
|
return WaitForCompactMemTable();
|
2012-06-23 04:30:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::TEST_WaitForCompact() {
|
2012-08-15 00:20:36 +02:00
|
|
|
// Wait until the compaction completes
|
|
|
|
MutexLock l(&mutex_);
|
|
|
|
while (bg_compaction_scheduled_ && bg_error_.ok()) {
|
|
|
|
bg_cv_.Wait();
|
|
|
|
}
|
|
|
|
return bg_error_;
|
2012-06-23 04:30:03 +02:00
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
void DBImpl::MaybeScheduleCompaction() {
|
|
|
|
mutex_.AssertHeld();
|
2012-10-19 23:00:53 +02:00
|
|
|
if (bg_compaction_scheduled_ >= options_.max_background_compactions) {
|
2011-03-18 23:37:00 +01:00
|
|
|
// Already scheduled
|
|
|
|
} else if (shutting_down_.Acquire_Load()) {
|
|
|
|
// DB is being deleted; no more background compactions
|
2013-06-11 23:23:58 +02:00
|
|
|
} else if (!imm_.IsFlushPending(options_.min_write_buffer_number_to_merge) &&
|
2013-02-15 20:53:17 +01:00
|
|
|
manual_compaction_ == nullptr &&
|
2011-06-07 16:40:26 +02:00
|
|
|
!versions_->NeedsCompaction()) {
|
2011-03-18 23:37:00 +01:00
|
|
|
// No work to be done
|
|
|
|
} else {
|
2012-10-19 23:00:53 +02:00
|
|
|
bg_compaction_scheduled_++;
|
2011-03-18 23:37:00 +01:00
|
|
|
env_->Schedule(&DBImpl::BGWork, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::BGWork(void* db) {
|
|
|
|
reinterpret_cast<DBImpl*>(db)->BackgroundCall();
|
|
|
|
}
|
|
|
|
|
2013-05-06 20:41:01 +02:00
|
|
|
void DBImpl::TEST_PurgeObsoleteteWAL() {
|
|
|
|
PurgeObsoleteWALFiles();
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
void DBImpl::BackgroundCall() {
|
2013-01-08 21:16:40 +01:00
|
|
|
bool madeProgress = false;
|
2012-10-21 10:49:48 +02:00
|
|
|
DeletionState deletion_state;
|
2013-05-24 21:52:45 +02:00
|
|
|
|
|
|
|
MaybeDumpStats();
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
MutexLock l(&mutex_);
|
2012-10-19 23:00:53 +02:00
|
|
|
// Log(options_.info_log, "XXX BG Thread %llx process new work item", pthread_self());
|
2011-03-18 23:37:00 +01:00
|
|
|
assert(bg_compaction_scheduled_);
|
2011-06-07 16:40:26 +02:00
|
|
|
if (!shutting_down_.Acquire_Load()) {
|
2012-10-21 10:55:19 +02:00
|
|
|
Status s = BackgroundCompaction(&madeProgress, deletion_state);
|
2012-08-23 01:57:51 +02:00
|
|
|
if (!s.ok()) {
|
|
|
|
// Wait a little bit before retrying background compaction in
|
|
|
|
// case this is an environmental problem and we do not want to
|
|
|
|
// chew up resources for failed compactions for the duration of
|
|
|
|
// the problem.
|
|
|
|
bg_cv_.SignalAll(); // In case a waiter can proceed despite the error
|
|
|
|
Log(options_.info_log, "Waiting after background compaction error: %s",
|
|
|
|
s.ToString().c_str());
|
|
|
|
mutex_.Unlock();
|
|
|
|
env_->SleepForMicroseconds(1000000);
|
|
|
|
mutex_.Lock();
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2012-08-23 01:57:51 +02:00
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
// delete unnecessary files if any, this is done outside the mutex
|
|
|
|
if (!deletion_state.live.empty()) {
|
|
|
|
mutex_.Unlock();
|
|
|
|
PurgeObsoleteFiles(deletion_state);
|
2012-10-21 10:49:48 +02:00
|
|
|
EvictObsoleteFiles(deletion_state);
|
2012-11-01 06:01:57 +01:00
|
|
|
mutex_.Lock();
|
2013-05-06 20:41:01 +02:00
|
|
|
|
2012-10-21 10:49:48 +02:00
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
bg_compaction_scheduled_--;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-08-15 00:20:36 +02:00
|
|
|
MaybeScheduleLogDBDeployStats();
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Previous compaction may have produced too many files in a level,
|
2012-11-29 01:42:36 +01:00
|
|
|
// So reschedule another compaction if we made progress in the
|
2012-10-19 23:00:53 +02:00
|
|
|
// last compaction.
|
|
|
|
if (madeProgress) {
|
|
|
|
MaybeScheduleCompaction();
|
|
|
|
}
|
2011-06-07 16:40:26 +02:00
|
|
|
bg_cv_.SignalAll();
|
2013-05-11 00:21:04 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-11-29 01:42:36 +01:00
|
|
|
Status DBImpl::BackgroundCompaction(bool* madeProgress,
|
2012-10-21 10:55:19 +02:00
|
|
|
DeletionState& deletion_state) {
|
2012-10-19 23:00:53 +02:00
|
|
|
*madeProgress = false;
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.AssertHeld();
|
2011-04-12 21:38:58 +02:00
|
|
|
|
2013-06-11 23:23:58 +02:00
|
|
|
while (imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) {
|
2012-11-29 01:42:36 +01:00
|
|
|
Log(options_.info_log,
|
2012-10-19 23:00:53 +02:00
|
|
|
"BackgroundCompaction doing CompactMemTable, compaction slots available %d",
|
|
|
|
options_.max_background_compactions - bg_compaction_scheduled_);
|
|
|
|
Status stat = CompactMemTable(madeProgress);
|
|
|
|
if (!stat.ok()) {
|
|
|
|
return stat;
|
|
|
|
}
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
|
|
|
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<Compaction> c;
|
2013-02-15 20:53:17 +01:00
|
|
|
bool is_manual = (manual_compaction_ != nullptr) &&
|
2012-10-19 23:00:53 +02:00
|
|
|
(manual_compaction_->in_progress == false);
|
2011-10-06 01:30:28 +02:00
|
|
|
InternalKey manual_end;
|
2011-06-07 16:40:26 +02:00
|
|
|
if (is_manual) {
|
2011-10-06 01:30:28 +02:00
|
|
|
ManualCompaction* m = manual_compaction_;
|
2012-10-19 23:00:53 +02:00
|
|
|
assert(!m->in_progress);
|
|
|
|
m->in_progress = true; // another thread cannot pick up the same work
|
2013-01-20 11:07:13 +01:00
|
|
|
c.reset(versions_->CompactRange(m->level, m->begin, m->end));
|
|
|
|
if (c) {
|
2011-10-06 01:30:28 +02:00
|
|
|
manual_end = c->input(0, c->num_input_files(0) - 1)->largest;
|
2013-01-20 11:07:13 +01:00
|
|
|
} else {
|
|
|
|
m->done = true;
|
2011-10-06 01:30:28 +02:00
|
|
|
}
|
|
|
|
Log(options_.info_log,
|
|
|
|
"Manual compaction at level-%d from %s .. %s; will stop at %s\n",
|
2011-06-07 16:40:26 +02:00
|
|
|
m->level,
|
2011-10-06 01:30:28 +02:00
|
|
|
(m->begin ? m->begin->DebugString().c_str() : "(begin)"),
|
|
|
|
(m->end ? m->end->DebugString().c_str() : "(end)"),
|
|
|
|
(m->done ? "(end)" : manual_end.DebugString().c_str()));
|
2012-11-21 00:45:41 +01:00
|
|
|
} else if (!options_.disable_auto_compactions) {
|
2013-01-20 11:07:13 +01:00
|
|
|
c.reset(versions_->PickCompaction());
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Status status;
|
2013-01-20 11:07:13 +01:00
|
|
|
if (!c) {
|
2011-06-07 16:40:26 +02:00
|
|
|
// Nothing to do
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Compaction nothing to do");
|
2011-06-07 16:40:26 +02:00
|
|
|
} else if (!is_manual && c->IsTrivialMove()) {
|
2011-03-18 23:37:00 +01:00
|
|
|
// Move file to next level
|
2011-03-22 19:32:49 +01:00
|
|
|
assert(c->num_input_files(0) == 1);
|
2011-03-18 23:37:00 +01:00
|
|
|
FileMetaData* f = c->input(0, 0);
|
|
|
|
c->edit()->DeleteFile(c->level(), f->number);
|
|
|
|
c->edit()->AddFile(c->level() + 1, f->number, f->file_size,
|
2013-06-14 07:09:08 +02:00
|
|
|
f->smallest, f->largest,
|
|
|
|
f->smallest_seqno, f->largest_seqno);
|
2011-09-01 21:08:02 +02:00
|
|
|
status = versions_->LogAndApply(c->edit(), &mutex_);
|
2011-06-07 16:40:26 +02:00
|
|
|
VersionSet::LevelSummaryStorage tmp;
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Moved #%lld to level-%d %lld bytes %s: %s\n",
|
2011-03-18 23:37:00 +01:00
|
|
|
static_cast<unsigned long long>(f->number),
|
|
|
|
c->level() + 1,
|
|
|
|
static_cast<unsigned long long>(f->file_size),
|
2011-06-07 16:40:26 +02:00
|
|
|
status.ToString().c_str(),
|
|
|
|
versions_->LevelSummary(&tmp));
|
2013-01-20 11:07:13 +01:00
|
|
|
versions_->ReleaseCompactionFiles(c.get(), status);
|
2012-10-19 23:00:53 +02:00
|
|
|
*madeProgress = true;
|
2011-03-18 23:37:00 +01:00
|
|
|
} else {
|
2013-03-20 23:14:10 +01:00
|
|
|
MaybeScheduleCompaction(); // do more compaction work in parallel.
|
2013-01-20 11:07:13 +01:00
|
|
|
CompactionState* compact = new CompactionState(c.get());
|
2011-03-18 23:37:00 +01:00
|
|
|
status = DoCompactionWork(compact);
|
|
|
|
CleanupCompaction(compact);
|
2013-01-20 11:07:13 +01:00
|
|
|
versions_->ReleaseCompactionFiles(c.get(), status);
|
2012-01-25 23:56:52 +01:00
|
|
|
c->ReleaseInputs();
|
2012-10-21 10:49:48 +02:00
|
|
|
FindObsoleteFiles(deletion_state);
|
2012-10-19 23:00:53 +02:00
|
|
|
*madeProgress = true;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2013-01-20 11:07:13 +01:00
|
|
|
c.reset();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
if (status.ok()) {
|
|
|
|
// Done
|
|
|
|
} else if (shutting_down_.Acquire_Load()) {
|
|
|
|
// Ignore compaction errors found during shutting down
|
|
|
|
} else {
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log,
|
2011-03-18 23:37:00 +01:00
|
|
|
"Compaction error: %s", status.ToString().c_str());
|
|
|
|
if (options_.paranoid_checks && bg_error_.ok()) {
|
|
|
|
bg_error_ = status;
|
|
|
|
}
|
|
|
|
}
|
2011-06-07 16:40:26 +02:00
|
|
|
|
|
|
|
if (is_manual) {
|
2011-10-06 01:30:28 +02:00
|
|
|
ManualCompaction* m = manual_compaction_;
|
2012-01-25 23:56:52 +01:00
|
|
|
if (!status.ok()) {
|
|
|
|
m->done = true;
|
|
|
|
}
|
2011-10-06 01:30:28 +02:00
|
|
|
if (!m->done) {
|
|
|
|
// We only compacted part of the requested range. Update *m
|
|
|
|
// to the range that is left to be compacted.
|
|
|
|
m->tmp_storage = manual_end;
|
|
|
|
m->begin = &m->tmp_storage;
|
|
|
|
}
|
2012-10-19 23:00:53 +02:00
|
|
|
m->in_progress = false; // not being processed anymore
|
2013-02-15 20:53:17 +01:00
|
|
|
manual_compaction_ = nullptr;
|
2011-06-07 16:40:26 +02:00
|
|
|
}
|
2012-08-23 01:57:51 +02:00
|
|
|
return status;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::CleanupCompaction(CompactionState* compact) {
|
|
|
|
mutex_.AssertHeld();
|
2013-02-15 20:53:17 +01:00
|
|
|
if (compact->builder != nullptr) {
|
2011-03-18 23:37:00 +01:00
|
|
|
// May happen if we get a shutdown call in the middle of compaction
|
|
|
|
compact->builder->Abandon();
|
2013-01-20 11:07:13 +01:00
|
|
|
compact->builder.reset();
|
2011-03-18 23:37:00 +01:00
|
|
|
} else {
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact->outfile == nullptr);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2011-04-21 00:48:11 +02:00
|
|
|
for (size_t i = 0; i < compact->outputs.size(); i++) {
|
2011-03-18 23:37:00 +01:00
|
|
|
const CompactionState::Output& out = compact->outputs[i];
|
|
|
|
pending_outputs_.erase(out.number);
|
|
|
|
}
|
|
|
|
delete compact;
|
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Allocate the file numbers for the output file. We allocate as
|
|
|
|
// many output file numbers as there are files in level+1.
|
|
|
|
// Insert them into pending_outputs so that they do not get deleted.
|
|
|
|
void DBImpl::AllocateCompactionOutputFileNumbers(CompactionState* compact) {
|
|
|
|
mutex_.AssertHeld();
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact != nullptr);
|
|
|
|
assert(compact->builder == nullptr);
|
2012-10-19 23:00:53 +02:00
|
|
|
int filesNeeded = compact->compaction->num_input_files(1);
|
2012-11-08 00:11:37 +01:00
|
|
|
for (int i = 0; i < filesNeeded; i++) {
|
2012-10-19 23:00:53 +02:00
|
|
|
uint64_t file_number = versions_->NewFileNumber();
|
|
|
|
pending_outputs_.insert(file_number);
|
|
|
|
compact->allocated_file_numbers.push_back(file_number);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Frees up unused file number.
|
|
|
|
void DBImpl::ReleaseCompactionUnusedFileNumbers(CompactionState* compact) {
|
|
|
|
mutex_.AssertHeld();
|
2013-03-29 02:01:06 +01:00
|
|
|
for (const auto file_number : compact->allocated_file_numbers) {
|
2012-10-19 23:00:53 +02:00
|
|
|
pending_outputs_.erase(file_number);
|
|
|
|
// Log(options_.info_log, "XXX releasing unused file num %d", file_number);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) {
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact != nullptr);
|
|
|
|
assert(compact->builder == nullptr);
|
2011-03-18 23:37:00 +01:00
|
|
|
uint64_t file_number;
|
2012-10-19 23:00:53 +02:00
|
|
|
// If we have not yet exhausted the pre-allocated file numbers,
|
|
|
|
// then use the one from the front. Otherwise, we have to acquire
|
|
|
|
// the heavyweight lock and allocate a new file number.
|
|
|
|
if (!compact->allocated_file_numbers.empty()) {
|
|
|
|
file_number = compact->allocated_file_numbers.front();
|
|
|
|
compact->allocated_file_numbers.pop_front();
|
|
|
|
} else {
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.Lock();
|
|
|
|
file_number = versions_->NewFileNumber();
|
|
|
|
pending_outputs_.insert(file_number);
|
|
|
|
mutex_.Unlock();
|
|
|
|
}
|
2012-10-19 23:00:53 +02:00
|
|
|
CompactionState::Output out;
|
|
|
|
out.number = file_number;
|
|
|
|
out.smallest.Clear();
|
|
|
|
out.largest.Clear();
|
2013-06-14 07:09:08 +02:00
|
|
|
out.smallest_seqno = out.largest_seqno = 0;
|
2012-10-19 23:00:53 +02:00
|
|
|
compact->outputs.push_back(out);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Make the output file
|
|
|
|
std::string fname = TableFileName(dbname_, file_number);
|
2013-03-15 01:00:04 +01:00
|
|
|
Status s = env_->NewWritableFile(fname, &compact->outfile, storage_options_);
|
2013-01-15 23:05:42 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
if (s.ok()) {
|
2013-04-10 17:37:03 +02:00
|
|
|
// Over-estimate slightly so we don't end up just barely crossing
|
|
|
|
// the threshold.
|
|
|
|
compact->outfile->SetPreallocationBlockSize(
|
2013-06-14 07:09:08 +02:00
|
|
|
1.1 * versions_->MaxFileSizeForLevel(compact->compaction->output_level()));
|
2013-04-10 17:37:03 +02:00
|
|
|
|
2013-01-20 11:07:13 +01:00
|
|
|
compact->builder.reset(new TableBuilder(options_, compact->outfile.get(),
|
2013-06-14 07:09:08 +02:00
|
|
|
compact->compaction->output_level()));
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DBImpl::FinishCompactionOutputFile(CompactionState* compact,
|
|
|
|
Iterator* input) {
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact != nullptr);
|
2013-01-20 11:07:13 +01:00
|
|
|
assert(compact->outfile);
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact->builder != nullptr);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
const uint64_t output_number = compact->current_output()->number;
|
|
|
|
assert(output_number != 0);
|
|
|
|
|
|
|
|
// Check for iterator errors
|
|
|
|
Status s = input->status();
|
|
|
|
const uint64_t current_entries = compact->builder->NumEntries();
|
|
|
|
if (s.ok()) {
|
|
|
|
s = compact->builder->Finish();
|
|
|
|
} else {
|
|
|
|
compact->builder->Abandon();
|
|
|
|
}
|
|
|
|
const uint64_t current_bytes = compact->builder->FileSize();
|
|
|
|
compact->current_output()->file_size = current_bytes;
|
|
|
|
compact->total_bytes += current_bytes;
|
2013-01-20 11:07:13 +01:00
|
|
|
compact->builder.reset();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Finish and check for file errors
|
2012-08-04 00:20:58 +02:00
|
|
|
if (s.ok() && !options_.disableDataSync) {
|
2012-08-27 21:10:26 +02:00
|
|
|
if (options_.use_fsync) {
|
2013-06-05 20:06:21 +02:00
|
|
|
StopWatch sw(env_, options_.statistics, COMPACTION_OUTFILE_SYNC_MICROS);
|
2012-08-27 21:10:26 +02:00
|
|
|
s = compact->outfile->Fsync();
|
|
|
|
} else {
|
2013-06-05 20:06:21 +02:00
|
|
|
StopWatch sw(env_, options_.statistics, COMPACTION_OUTFILE_SYNC_MICROS);
|
2012-08-27 21:10:26 +02:00
|
|
|
s = compact->outfile->Sync();
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
if (s.ok()) {
|
|
|
|
s = compact->outfile->Close();
|
|
|
|
}
|
2013-01-20 11:07:13 +01:00
|
|
|
compact->outfile.reset();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
if (s.ok() && current_entries > 0) {
|
|
|
|
// Verify that the table is usable
|
2011-03-28 22:43:44 +02:00
|
|
|
Iterator* iter = table_cache_->NewIterator(ReadOptions(),
|
2013-03-15 01:00:04 +01:00
|
|
|
storage_options_,
|
2011-03-28 22:43:44 +02:00
|
|
|
output_number,
|
|
|
|
current_bytes);
|
2011-03-18 23:37:00 +01:00
|
|
|
s = iter->status();
|
|
|
|
delete iter;
|
|
|
|
if (s.ok()) {
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log,
|
2011-03-18 23:37:00 +01:00
|
|
|
"Generated table #%llu: %lld keys, %lld bytes",
|
|
|
|
(unsigned long long) output_number,
|
|
|
|
(unsigned long long) current_entries,
|
|
|
|
(unsigned long long) current_bytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Status DBImpl::InstallCompactionResults(CompactionState* compact) {
|
|
|
|
mutex_.AssertHeld();
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
// paranoia: verify that the files that we started with
|
|
|
|
// 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.
|
2013-03-06 22:28:54 +01:00
|
|
|
if (!versions_->VerifyCompactionFileConsistency(compact->compaction)) {
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "Compaction %d@%d + %d@%d files aborted",
|
|
|
|
compact->compaction->num_input_files(0),
|
|
|
|
compact->compaction->level(),
|
|
|
|
compact->compaction->num_input_files(1),
|
|
|
|
compact->compaction->level() + 1);
|
|
|
|
return Status::IOError("Compaction input files inconsistent");
|
|
|
|
}
|
|
|
|
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log, "Compacted %d@%d + %d@%d files => %lld bytes",
|
2011-03-18 23:37:00 +01:00
|
|
|
compact->compaction->num_input_files(0),
|
|
|
|
compact->compaction->level(),
|
|
|
|
compact->compaction->num_input_files(1),
|
|
|
|
compact->compaction->level() + 1,
|
|
|
|
static_cast<long long>(compact->total_bytes));
|
|
|
|
|
|
|
|
// Add compaction outputs
|
|
|
|
compact->compaction->AddInputDeletions(compact->compaction->edit());
|
|
|
|
const int level = compact->compaction->level();
|
2011-04-21 00:48:11 +02:00
|
|
|
for (size_t i = 0; i < compact->outputs.size(); i++) {
|
2011-03-18 23:37:00 +01:00
|
|
|
const CompactionState::Output& out = compact->outputs[i];
|
|
|
|
compact->compaction->edit()->AddFile(
|
2013-06-14 07:09:08 +02:00
|
|
|
options_.hybrid_mode? level : level + 1,
|
|
|
|
out.number, out.file_size, out.smallest, out.largest,
|
|
|
|
out.smallest_seqno, out.largest_seqno);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2012-01-25 23:56:52 +01:00
|
|
|
return versions_->LogAndApply(compact->compaction->edit(), &mutex_);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-11-27 06:16:21 +01:00
|
|
|
//
|
|
|
|
// Given a sequence number, return the sequence number of the
|
|
|
|
// earliest snapshot that this sequence number is visible in.
|
|
|
|
// The snapshots themselves are arranged in ascending order of
|
|
|
|
// sequence numbers.
|
|
|
|
// Employ a sequential search because the total number of
|
|
|
|
// snapshots are typically small.
|
|
|
|
inline SequenceNumber DBImpl::findEarliestVisibleSnapshot(
|
2013-03-21 23:59:47 +01:00
|
|
|
SequenceNumber in, std::vector<SequenceNumber>& snapshots,
|
|
|
|
SequenceNumber* prev_snapshot) {
|
2013-01-14 21:39:24 +01:00
|
|
|
SequenceNumber prev __attribute__((unused)) = 0;
|
2013-03-29 02:01:06 +01:00
|
|
|
for (const auto cur : snapshots) {
|
|
|
|
assert(prev <= cur);
|
|
|
|
if (cur >= in) {
|
2013-03-21 23:59:47 +01:00
|
|
|
*prev_snapshot = prev;
|
2013-03-29 02:01:06 +01:00
|
|
|
return cur;
|
2012-11-27 06:16:21 +01:00
|
|
|
}
|
2013-03-29 02:01:06 +01:00
|
|
|
prev = cur; // assignment
|
|
|
|
assert(prev);
|
2012-11-27 06:16:21 +01:00
|
|
|
}
|
|
|
|
Log(options_.info_log,
|
|
|
|
"Looking for seqid %ld but maxseqid is %ld", in,
|
|
|
|
snapshots[snapshots.size()-1]);
|
|
|
|
assert(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DBImpl::DoCompactionWork(CompactionState* compact) {
|
2011-04-12 21:38:58 +02:00
|
|
|
int64_t imm_micros = 0; // Micros spent doing imm_ compactions
|
|
|
|
|
2012-11-29 01:42:36 +01:00
|
|
|
Log(options_.info_log,
|
2012-12-04 18:47:05 +01:00
|
|
|
"Compacting %d@%d + %d@%d files, score %.2f slots available %d",
|
2011-03-18 23:37:00 +01:00
|
|
|
compact->compaction->num_input_files(0),
|
|
|
|
compact->compaction->level(),
|
|
|
|
compact->compaction->num_input_files(1),
|
2012-10-19 23:00:53 +02:00
|
|
|
compact->compaction->level() + 1,
|
2012-12-04 18:47:05 +01:00
|
|
|
compact->compaction->score(),
|
2012-10-19 23:00:53 +02:00
|
|
|
options_.max_background_compactions - bg_compaction_scheduled_);
|
2012-09-21 19:47:08 +02:00
|
|
|
char scratch[256];
|
|
|
|
compact->compaction->Summary(scratch, sizeof(scratch));
|
2012-08-18 03:10:09 +02:00
|
|
|
Log(options_.info_log, "Compaction start summary: %s\n", scratch);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
assert(versions_->NumLevelFiles(compact->compaction->level()) > 0);
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(compact->builder == nullptr);
|
2013-01-20 11:07:13 +01:00
|
|
|
assert(!compact->outfile);
|
2012-11-27 06:16:21 +01:00
|
|
|
|
|
|
|
SequenceNumber visible_at_tip = 0;
|
|
|
|
SequenceNumber earliest_snapshot;
|
2013-06-06 19:31:37 +02:00
|
|
|
SequenceNumber latest_snapshot = 0;
|
2012-11-27 06:16:21 +01:00
|
|
|
snapshots_.getAll(compact->existing_snapshots);
|
|
|
|
if (compact->existing_snapshots.size() == 0) {
|
|
|
|
// optimize for fast path if there are no snapshots
|
|
|
|
visible_at_tip = versions_->LastSequence();
|
|
|
|
earliest_snapshot = visible_at_tip;
|
2011-03-18 23:37:00 +01:00
|
|
|
} else {
|
2013-06-06 19:31:37 +02:00
|
|
|
latest_snapshot = compact->existing_snapshots.back();
|
2012-11-27 06:16:21 +01:00
|
|
|
// Add the current seqno as the 'latest' virtual
|
|
|
|
// snapshot to the end of this list.
|
|
|
|
compact->existing_snapshots.push_back(versions_->LastSequence());
|
|
|
|
earliest_snapshot = compact->existing_snapshots[0];
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2013-02-15 23:31:24 +01:00
|
|
|
// Is this compaction producing files at the bottommost level?
|
|
|
|
bool bottommost_level = true;
|
|
|
|
for (int i = compact->compaction->level() + 2;
|
|
|
|
i < versions_->NumberLevels(); i++) {
|
|
|
|
if (versions_->NumLevelFiles(i) > 0) {
|
|
|
|
bottommost_level = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Allocate the output file numbers before we release the lock
|
|
|
|
AllocateCompactionOutputFileNumbers(compact);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Release mutex while we're actually doing the compaction work
|
|
|
|
mutex_.Unlock();
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
const uint64_t start_micros = env_->NowMicros();
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<Iterator> input(versions_->MakeInputIterator(compact->compaction));
|
2011-03-18 23:37:00 +01:00
|
|
|
input->SeekToFirst();
|
|
|
|
Status status;
|
|
|
|
ParsedInternalKey ikey;
|
|
|
|
std::string current_user_key;
|
|
|
|
bool has_current_user_key = false;
|
2013-01-14 21:39:24 +01:00
|
|
|
SequenceNumber last_sequence_for_key __attribute__((unused)) =
|
|
|
|
kMaxSequenceNumber;
|
2012-11-27 06:16:21 +01:00
|
|
|
SequenceNumber visible_in_snapshot = kMaxSequenceNumber;
|
2013-04-18 06:30:21 +02:00
|
|
|
std::string compaction_filter_value;
|
2013-06-06 19:31:37 +02:00
|
|
|
std::vector<char> delete_key; // for compaction filter
|
2013-03-21 23:59:47 +01:00
|
|
|
MergeHelper merge(user_comparator(), options_.merge_operator,
|
|
|
|
options_.info_log.get(),
|
|
|
|
false /* internal key corruption is expected */);
|
2011-03-18 23:37:00 +01:00
|
|
|
for (; input->Valid() && !shutting_down_.Acquire_Load(); ) {
|
2011-04-12 21:38:58 +02:00
|
|
|
// Prioritize immutable compaction work
|
2013-02-15 20:53:17 +01:00
|
|
|
if (imm_.imm_flush_needed.NoBarrier_Load() != nullptr) {
|
2011-04-12 21:38:58 +02:00
|
|
|
const uint64_t imm_start = env_->NowMicros();
|
|
|
|
mutex_.Lock();
|
2013-06-11 23:23:58 +02:00
|
|
|
if (imm_.IsFlushPending(options_.min_write_buffer_number_to_merge)) {
|
2011-04-12 21:38:58 +02:00
|
|
|
CompactMemTable();
|
2011-06-07 16:40:26 +02:00
|
|
|
bg_cv_.SignalAll(); // Wakeup MakeRoomForWrite() if necessary
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
|
|
|
mutex_.Unlock();
|
|
|
|
imm_micros += (env_->NowMicros() - imm_start);
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Slice key = input->key();
|
2012-10-29 09:13:41 +01:00
|
|
|
Slice value = input->value();
|
2013-04-18 06:30:21 +02:00
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
if (compact->compaction->ShouldStopBefore(key) &&
|
2013-02-15 20:53:17 +01:00
|
|
|
compact->builder != nullptr) {
|
2013-01-20 11:07:13 +01:00
|
|
|
status = FinishCompactionOutputFile(compact, input.get());
|
2011-03-22 19:32:49 +01:00
|
|
|
if (!status.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle key/value, add to state, etc.
|
2011-03-18 23:37:00 +01:00
|
|
|
bool drop = false;
|
2013-03-21 23:59:47 +01:00
|
|
|
bool current_entry_is_merged = false;
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!ParseInternalKey(key, &ikey)) {
|
|
|
|
// Do not hide error keys
|
2013-03-21 23:59:47 +01:00
|
|
|
// TODO: error key stays in db forever? Figure out the intention/rationale
|
|
|
|
// v10 error v8 : we cannot hide v8 even though it's pretty obvious.
|
2011-03-18 23:37:00 +01:00
|
|
|
current_user_key.clear();
|
|
|
|
has_current_user_key = false;
|
|
|
|
last_sequence_for_key = kMaxSequenceNumber;
|
2012-11-27 06:16:21 +01:00
|
|
|
visible_in_snapshot = kMaxSequenceNumber;
|
2011-03-18 23:37:00 +01:00
|
|
|
} else {
|
|
|
|
if (!has_current_user_key ||
|
|
|
|
user_comparator()->Compare(ikey.user_key,
|
|
|
|
Slice(current_user_key)) != 0) {
|
|
|
|
// First occurrence of this user key
|
|
|
|
current_user_key.assign(ikey.user_key.data(), ikey.user_key.size());
|
|
|
|
has_current_user_key = true;
|
|
|
|
last_sequence_for_key = kMaxSequenceNumber;
|
2012-11-27 06:16:21 +01:00
|
|
|
visible_in_snapshot = kMaxSequenceNumber;
|
2013-06-06 19:31:37 +02:00
|
|
|
|
|
|
|
// apply the compaction filter to the first occurrence of the user key
|
|
|
|
if (options_.compaction_filter &&
|
|
|
|
ikey.type == kTypeValue &&
|
|
|
|
(visible_at_tip || ikey.sequence > latest_snapshot)) {
|
|
|
|
// If the user has specified a compaction filter and the sequence
|
|
|
|
// number is greater than any external snapshot, then invoke the
|
|
|
|
// filter.
|
|
|
|
// If the return value of the compaction filter is true, replace
|
|
|
|
// the entry with a delete marker.
|
|
|
|
bool value_changed = false;
|
|
|
|
compaction_filter_value.clear();
|
|
|
|
bool to_delete =
|
|
|
|
options_.compaction_filter->Filter(compact->compaction->level(),
|
|
|
|
ikey.user_key, value,
|
|
|
|
&compaction_filter_value,
|
|
|
|
&value_changed);
|
|
|
|
if (to_delete) {
|
|
|
|
// make a copy of the original key
|
|
|
|
delete_key.assign(key.data(), key.data() + key.size());
|
|
|
|
// convert it to a delete
|
|
|
|
UpdateInternalKey(&delete_key[0], delete_key.size(),
|
|
|
|
ikey.sequence, kTypeDeletion);
|
|
|
|
// anchor the key again
|
|
|
|
key = Slice(&delete_key[0], delete_key.size());
|
|
|
|
// needed because ikey is backed by key
|
|
|
|
ParseInternalKey(key, &ikey);
|
|
|
|
// no value associated with delete
|
|
|
|
value.clear();
|
|
|
|
RecordTick(options_.statistics, COMPACTION_KEY_DROP_USER);
|
|
|
|
} else if (value_changed) {
|
|
|
|
value = compaction_filter_value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2012-11-27 06:16:21 +01:00
|
|
|
// If there are no snapshots, then this kv affect visibility at tip.
|
|
|
|
// Otherwise, search though all existing snapshots to find
|
|
|
|
// the earlist snapshot that is affected by this kv.
|
2013-03-21 23:59:47 +01:00
|
|
|
SequenceNumber prev_snapshot = 0; // 0 means no previous snapshot
|
|
|
|
SequenceNumber visible = visible_at_tip ?
|
|
|
|
visible_at_tip :
|
|
|
|
findEarliestVisibleSnapshot(ikey.sequence,
|
|
|
|
compact->existing_snapshots,
|
|
|
|
&prev_snapshot);
|
2012-11-27 06:16:21 +01:00
|
|
|
|
|
|
|
if (visible_in_snapshot == visible) {
|
|
|
|
// If the earliest snapshot is which this key is visible in
|
|
|
|
// is the same as the visibily of a previous instance of the
|
|
|
|
// same key, then this kv is not visible in any snapshot.
|
2011-03-18 23:37:00 +01:00
|
|
|
// Hidden by an newer entry for same user key
|
2013-03-21 23:59:47 +01:00
|
|
|
// TODO: why not > ?
|
2012-11-27 06:16:21 +01:00
|
|
|
assert(last_sequence_for_key >= ikey.sequence);
|
2011-03-18 23:37:00 +01:00
|
|
|
drop = true; // (A)
|
2012-11-09 03:18:34 +01:00
|
|
|
RecordTick(options_.statistics, COMPACTION_KEY_DROP_NEWER_ENTRY);
|
2011-03-18 23:37:00 +01:00
|
|
|
} else if (ikey.type == kTypeDeletion &&
|
2012-11-27 06:16:21 +01:00
|
|
|
ikey.sequence <= earliest_snapshot &&
|
2011-03-18 23:37:00 +01:00
|
|
|
compact->compaction->IsBaseLevelForKey(ikey.user_key)) {
|
|
|
|
// For this user key:
|
|
|
|
// (1) there is no data in higher levels
|
|
|
|
// (2) data in lower levels will have larger sequence numbers
|
|
|
|
// (3) data in layers that are being compacted here and have
|
|
|
|
// smaller sequence numbers will be dropped in the next
|
|
|
|
// few iterations of this loop (by rule (A) above).
|
|
|
|
// Therefore this deletion marker is obsolete and can be dropped.
|
|
|
|
drop = true;
|
2012-11-09 03:18:34 +01:00
|
|
|
RecordTick(options_.statistics, COMPACTION_KEY_DROP_OBSOLETE);
|
2013-03-21 23:59:47 +01:00
|
|
|
} else if (ikey.type == kTypeMerge) {
|
|
|
|
// We know the merge type entry is not hidden, otherwise we would
|
|
|
|
// have hit (A)
|
|
|
|
// We encapsulate the merge related state machine in a different
|
|
|
|
// object to minimize change to the existing flow. Turn out this
|
|
|
|
// logic could also be nicely re-used for memtable flush purge
|
|
|
|
// optimization in BuildTable.
|
|
|
|
merge.MergeUntil(input.get(), prev_snapshot, bottommost_level);
|
|
|
|
current_entry_is_merged = true;
|
|
|
|
// get the merge result
|
|
|
|
key = merge.key();
|
|
|
|
ParseInternalKey(key, &ikey);
|
|
|
|
value = merge.value();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
last_sequence_for_key = ikey.sequence;
|
2012-11-27 06:16:21 +01:00
|
|
|
visible_in_snapshot = visible;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
#if 0
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log,
|
2011-03-18 23:37:00 +01:00
|
|
|
" Compact: %s, seq %d, type: %d %d, drop: %d, is_base: %d, "
|
2013-02-15 23:31:24 +01:00
|
|
|
"%d smallest_snapshot: %d level: %d bottommost %d",
|
2011-03-18 23:37:00 +01:00
|
|
|
ikey.user_key.ToString().c_str(),
|
2011-04-21 00:48:11 +02:00
|
|
|
(int)ikey.sequence, ikey.type, kTypeValue, drop,
|
2011-03-18 23:37:00 +01:00
|
|
|
compact->compaction->IsBaseLevelForKey(ikey.user_key),
|
2013-02-15 23:31:24 +01:00
|
|
|
(int)last_sequence_for_key, (int)earliest_snapshot,
|
|
|
|
compact->compaction->level(), bottommost_level);
|
2011-03-18 23:37:00 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!drop) {
|
2013-02-15 23:31:24 +01:00
|
|
|
|
2013-03-06 06:53:28 +01:00
|
|
|
char* kptr = (char*)key.data();
|
|
|
|
std::string kstr;
|
|
|
|
|
2013-02-15 23:31:24 +01:00
|
|
|
// Zeroing out the sequence number leads to better compression.
|
|
|
|
// If this is the bottommost level (no files in lower levels)
|
|
|
|
// and the earliest snapshot is larger than this seqno
|
|
|
|
// then we can squash the seqno to zero.
|
2013-06-14 07:09:08 +02:00
|
|
|
// Hybrid mode depends on the sequence number to determine
|
|
|
|
// time-order of files that is needed for compactions.
|
|
|
|
if (!options_.hybrid_mode &&
|
|
|
|
bottommost_level && ikey.sequence < earliest_snapshot &&
|
2013-03-21 23:59:47 +01:00
|
|
|
ikey.type != kTypeMerge) {
|
2013-02-15 23:31:24 +01:00
|
|
|
assert(ikey.type != kTypeDeletion);
|
2013-03-06 06:53:28 +01:00
|
|
|
// make a copy because updating in place would cause problems
|
|
|
|
// with the priority queue that is managing the input key iterator
|
|
|
|
kstr.assign(key.data(), key.size());
|
|
|
|
kptr = (char *)kstr.c_str();
|
|
|
|
UpdateInternalKey(kptr, key.size(), (uint64_t)0, ikey.type);
|
2013-02-15 23:31:24 +01:00
|
|
|
}
|
2013-02-21 04:22:13 +01:00
|
|
|
|
2013-03-06 06:53:28 +01:00
|
|
|
Slice newkey(kptr, key.size());
|
|
|
|
assert((key.clear(), 1)); // we do not need 'key' anymore
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Open output file if necessary
|
2013-02-15 20:53:17 +01:00
|
|
|
if (compact->builder == nullptr) {
|
2011-03-18 23:37:00 +01:00
|
|
|
status = OpenCompactionOutputFile(compact);
|
|
|
|
if (!status.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-06-14 07:09:08 +02:00
|
|
|
SequenceNumber seqno = GetInternalKeySeqno(newkey);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (compact->builder->NumEntries() == 0) {
|
2013-03-06 06:53:28 +01:00
|
|
|
compact->current_output()->smallest.DecodeFrom(newkey);
|
2013-06-14 07:09:08 +02:00
|
|
|
compact->current_output()->smallest_seqno = seqno;
|
|
|
|
} else {
|
|
|
|
compact->current_output()->smallest_seqno =
|
|
|
|
std::min(compact->current_output()->smallest_seqno, seqno);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2013-03-06 06:53:28 +01:00
|
|
|
compact->current_output()->largest.DecodeFrom(newkey);
|
|
|
|
compact->builder->Add(newkey, value);
|
2013-06-14 07:09:08 +02:00
|
|
|
compact->current_output()->largest_seqno =
|
|
|
|
std::max(compact->current_output()->largest_seqno, seqno);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
// Close output file if it is big enough
|
|
|
|
if (compact->builder->FileSize() >=
|
|
|
|
compact->compaction->MaxOutputFileSize()) {
|
2013-01-20 11:07:13 +01:00
|
|
|
status = FinishCompactionOutputFile(compact, input.get());
|
2011-03-18 23:37:00 +01:00
|
|
|
if (!status.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-21 23:59:47 +01:00
|
|
|
// MergeUntil has moved input to the next entry
|
|
|
|
if (!current_entry_is_merged) {
|
|
|
|
input->Next();
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (status.ok() && shutting_down_.Acquire_Load()) {
|
2013-04-16 00:27:15 +02:00
|
|
|
status = Status::IOError("Database shutdown started during compaction");
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2013-02-15 20:53:17 +01:00
|
|
|
if (status.ok() && compact->builder != nullptr) {
|
2013-01-20 11:07:13 +01:00
|
|
|
status = FinishCompactionOutputFile(compact, input.get());
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
if (status.ok()) {
|
|
|
|
status = input->status();
|
|
|
|
}
|
2013-01-20 11:07:13 +01:00
|
|
|
input.reset();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
CompactionStats stats;
|
|
|
|
stats.micros = env_->NowMicros() - start_micros - imm_micros;
|
2013-02-22 01:23:33 +01:00
|
|
|
if (options_.statistics) {
|
|
|
|
options_.statistics->measureTime(COMPACTION_TIME, stats.micros);
|
|
|
|
}
|
2012-10-23 19:34:09 +02:00
|
|
|
stats.files_in_leveln = compact->compaction->num_input_files(0);
|
|
|
|
stats.files_in_levelnp1 = compact->compaction->num_input_files(1);
|
2013-01-17 19:04:45 +01:00
|
|
|
|
|
|
|
int num_output_files = compact->outputs.size();
|
2013-02-15 20:53:17 +01:00
|
|
|
if (compact->builder != nullptr) {
|
2013-01-17 19:04:45 +01:00
|
|
|
// An error occured so ignore the last output.
|
|
|
|
assert(num_output_files > 0);
|
|
|
|
--num_output_files;
|
|
|
|
}
|
|
|
|
stats.files_out_levelnp1 = num_output_files;
|
2012-10-23 19:34:09 +02:00
|
|
|
|
|
|
|
for (int i = 0; i < compact->compaction->num_input_files(0); i++)
|
|
|
|
stats.bytes_readn += compact->compaction->input(0, i)->file_size;
|
|
|
|
|
|
|
|
for (int i = 0; i < compact->compaction->num_input_files(1); i++)
|
|
|
|
stats.bytes_readnp1 += compact->compaction->input(1, i)->file_size;
|
|
|
|
|
2013-01-17 19:04:45 +01:00
|
|
|
for (int i = 0; i < num_output_files; i++) {
|
2011-04-12 21:38:58 +02:00
|
|
|
stats.bytes_written += compact->outputs[i].file_size;
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.Lock();
|
2011-04-12 21:38:58 +02:00
|
|
|
stats_[compact->compaction->level() + 1].Add(stats);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// if there were any unused file number (mostly in case of
|
|
|
|
// compaction error), free up the entry from pending_putputs
|
|
|
|
ReleaseCompactionUnusedFileNumbers(compact);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
if (status.ok()) {
|
|
|
|
status = InstallCompactionResults(compact);
|
|
|
|
}
|
2011-05-21 04:17:43 +02:00
|
|
|
VersionSet::LevelSummaryStorage tmp;
|
2011-07-21 04:40:18 +02:00
|
|
|
Log(options_.info_log,
|
2012-10-23 19:34:09 +02:00
|
|
|
"compacted to: %s, %.1f MB/sec, level %d, files in(%d, %d) out(%d) "
|
2012-11-28 07:10:20 +01:00
|
|
|
"MB in(%.1f, %.1f) out(%.1f), amplify(%.1f) %s\n",
|
2012-10-23 19:34:09 +02:00
|
|
|
versions_->LevelSummary(&tmp),
|
|
|
|
(stats.bytes_readn + stats.bytes_readnp1 + stats.bytes_written) /
|
|
|
|
(double) stats.micros,
|
|
|
|
compact->compaction->level() + 1,
|
|
|
|
stats.files_in_leveln, stats.files_in_levelnp1, stats.files_out_levelnp1,
|
|
|
|
stats.bytes_readn / 1048576.0,
|
|
|
|
stats.bytes_readnp1 / 1048576.0,
|
|
|
|
stats.bytes_written / 1048576.0,
|
|
|
|
(stats.bytes_written + stats.bytes_readnp1) /
|
2012-11-28 07:10:20 +01:00
|
|
|
(double) stats.bytes_readn,
|
|
|
|
status.ToString().c_str());
|
2012-10-23 19:34:09 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-05-28 02:53:58 +02:00
|
|
|
namespace {
|
|
|
|
struct IterState {
|
|
|
|
port::Mutex* mu;
|
|
|
|
Version* version;
|
2012-10-19 23:00:53 +02:00
|
|
|
std::vector<MemTable*> mem; // includes both mem_ and imm_
|
2011-05-28 02:53:58 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static void CleanupIteratorState(void* arg1, void* arg2) {
|
|
|
|
IterState* state = reinterpret_cast<IterState*>(arg1);
|
|
|
|
state->mu->Lock();
|
2012-10-19 23:00:53 +02:00
|
|
|
for (unsigned int i = 0; i < state->mem.size(); i++) {
|
|
|
|
state->mem[i]->Unref();
|
|
|
|
}
|
2011-05-28 02:53:58 +02:00
|
|
|
state->version->Unref();
|
|
|
|
state->mu->Unlock();
|
|
|
|
delete state;
|
|
|
|
}
|
2011-10-31 18:22:06 +01:00
|
|
|
} // namespace
|
2011-05-28 02:53:58 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Iterator* DBImpl::NewInternalIterator(const ReadOptions& options,
|
|
|
|
SequenceNumber* latest_snapshot) {
|
2011-05-28 02:53:58 +02:00
|
|
|
IterState* cleanup = new IterState;
|
2011-03-18 23:37:00 +01:00
|
|
|
mutex_.Lock();
|
2011-04-12 21:38:58 +02:00
|
|
|
*latest_snapshot = versions_->LastSequence();
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
// Collect together all needed child iterators for mem
|
2011-03-18 23:37:00 +01:00
|
|
|
std::vector<Iterator*> list;
|
2011-05-28 02:53:58 +02:00
|
|
|
mem_->Ref();
|
2012-10-19 23:00:53 +02:00
|
|
|
list.push_back(mem_->NewIterator());
|
|
|
|
cleanup->mem.push_back(mem_);
|
|
|
|
|
|
|
|
// Collect together all needed child iterators for imm_
|
|
|
|
std::vector<MemTable*> immutables;
|
|
|
|
imm_.GetMemTables(&immutables);
|
|
|
|
for (unsigned int i = 0; i < immutables.size(); i++) {
|
|
|
|
MemTable* m = immutables[i];
|
|
|
|
m->Ref();
|
|
|
|
list.push_back(m->NewIterator());
|
|
|
|
cleanup->mem.push_back(m);
|
2011-04-12 21:38:58 +02:00
|
|
|
}
|
2012-10-19 23:00:53 +02:00
|
|
|
|
|
|
|
// Collect iterators for files in L0 - Ln
|
2013-03-15 01:00:04 +01:00
|
|
|
versions_->current()->AddIterators(options, storage_options_, &list);
|
2011-03-18 23:37:00 +01:00
|
|
|
Iterator* internal_iter =
|
|
|
|
NewMergingIterator(&internal_comparator_, &list[0], list.size());
|
|
|
|
versions_->current()->Ref();
|
2011-05-28 02:53:58 +02:00
|
|
|
|
|
|
|
cleanup->mu = &mutex_;
|
|
|
|
cleanup->version = versions_->current();
|
2013-02-15 20:53:17 +01:00
|
|
|
internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);
|
2011-03-18 23:37:00 +01:00
|
|
|
|
|
|
|
mutex_.Unlock();
|
|
|
|
return internal_iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
Iterator* DBImpl::TEST_NewInternalIterator() {
|
|
|
|
SequenceNumber ignored;
|
|
|
|
return NewInternalIterator(ReadOptions(), &ignored);
|
|
|
|
}
|
|
|
|
|
2011-03-23 00:24:02 +01:00
|
|
|
int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes() {
|
2011-03-22 19:32:49 +01:00
|
|
|
MutexLock l(&mutex_);
|
|
|
|
return versions_->MaxNextLevelOverlappingBytes();
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DBImpl::Get(const ReadOptions& options,
|
|
|
|
const Slice& key,
|
|
|
|
std::string* value) {
|
2011-06-22 04:36:45 +02:00
|
|
|
Status s;
|
2013-03-26 02:01:47 +01:00
|
|
|
|
2013-05-17 19:55:34 +02:00
|
|
|
StopWatch sw(env_, options_.statistics, DB_GET);
|
2011-06-22 04:36:45 +02:00
|
|
|
SequenceNumber snapshot;
|
2013-03-26 02:01:47 +01:00
|
|
|
MutexLock l(&mutex_);
|
2013-02-15 20:53:17 +01:00
|
|
|
if (options.snapshot != nullptr) {
|
2011-06-22 04:36:45 +02:00
|
|
|
snapshot = reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_;
|
|
|
|
} else {
|
|
|
|
snapshot = versions_->LastSequence();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2011-06-22 04:36:45 +02:00
|
|
|
|
2011-08-22 23:08:51 +02:00
|
|
|
MemTable* mem = mem_;
|
2012-10-19 23:00:53 +02:00
|
|
|
MemTableList imm = imm_;
|
2011-06-22 04:36:45 +02:00
|
|
|
Version* current = versions_->current();
|
2011-08-22 23:08:51 +02:00
|
|
|
mem->Ref();
|
2012-10-19 23:00:53 +02:00
|
|
|
imm.RefAll();
|
2011-06-22 04:36:45 +02:00
|
|
|
current->Ref();
|
2011-08-22 23:08:51 +02:00
|
|
|
|
2013-03-26 02:01:47 +01:00
|
|
|
// Unlock while reading from files and memtables
|
|
|
|
|
|
|
|
mutex_.Unlock();
|
2011-08-22 23:08:51 +02:00
|
|
|
bool have_stat_update = false;
|
2011-06-22 04:36:45 +02:00
|
|
|
Version::GetStats stats;
|
2013-03-21 23:59:47 +01:00
|
|
|
|
2013-03-26 02:01:47 +01:00
|
|
|
// First look in the memtable, then in the immutable memtable (if any).
|
2013-03-21 23:59:47 +01:00
|
|
|
// s is both in/out. When in, s could either be OK or MergeInProgress.
|
|
|
|
// value will contain the current merge operand in the latter case.
|
2013-03-26 02:01:47 +01:00
|
|
|
LookupKey lkey(key, snapshot);
|
2013-03-21 23:59:47 +01:00
|
|
|
if (mem->Get(lkey, value, &s, options_)) {
|
2013-03-26 02:01:47 +01:00
|
|
|
// Done
|
2013-03-21 23:59:47 +01:00
|
|
|
} else if (imm.Get(lkey, value, &s, options_)) {
|
2013-03-26 02:01:47 +01:00
|
|
|
// Done
|
|
|
|
} else {
|
2013-03-21 23:59:47 +01:00
|
|
|
current->Get(options, lkey, value, &s, &stats, options_);
|
2013-03-26 02:01:47 +01:00
|
|
|
have_stat_update = true;
|
2011-06-22 04:36:45 +02:00
|
|
|
}
|
2013-03-26 02:01:47 +01:00
|
|
|
mutex_.Lock();
|
2011-08-22 23:08:51 +02:00
|
|
|
|
2012-09-25 18:15:32 +02:00
|
|
|
if (!options_.disable_seek_compaction &&
|
|
|
|
have_stat_update && current->UpdateStats(stats)) {
|
2011-06-22 04:36:45 +02:00
|
|
|
MaybeScheduleCompaction();
|
|
|
|
}
|
2011-08-22 23:08:51 +02:00
|
|
|
mem->Unref();
|
2012-10-19 23:00:53 +02:00
|
|
|
imm.UnrefAll();
|
2011-06-22 04:36:45 +02:00
|
|
|
current->Unref();
|
2013-01-16 01:48:22 +01:00
|
|
|
RecordTick(options_.statistics, NUMBER_KEYS_READ);
|
2013-02-21 04:22:13 +01:00
|
|
|
RecordTick(options_.statistics, BYTES_READ, value->size());
|
2011-06-22 04:36:45 +02:00
|
|
|
return s;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
2013-06-05 20:22:38 +02:00
|
|
|
std::vector<Status> DBImpl::MultiGet(const ReadOptions& options,
|
|
|
|
const std::vector<Slice>& keys,
|
|
|
|
std::vector<std::string>* values) {
|
|
|
|
|
|
|
|
StopWatch sw(env_, options_.statistics, DB_MULTIGET);
|
|
|
|
SequenceNumber snapshot;
|
|
|
|
MutexLock l(&mutex_);
|
|
|
|
if (options.snapshot != nullptr) {
|
|
|
|
snapshot = reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_;
|
|
|
|
} else {
|
|
|
|
snapshot = versions_->LastSequence();
|
|
|
|
}
|
|
|
|
|
|
|
|
MemTable* mem = mem_;
|
|
|
|
MemTableList imm = imm_;
|
|
|
|
Version* current = versions_->current();
|
|
|
|
mem->Ref();
|
|
|
|
imm.RefAll();
|
|
|
|
current->Ref();
|
|
|
|
|
|
|
|
// Unlock while reading from files and memtables
|
|
|
|
|
|
|
|
mutex_.Unlock();
|
|
|
|
bool have_stat_update = false;
|
|
|
|
Version::GetStats stats;
|
|
|
|
|
|
|
|
// Note: this always resizes the values array
|
|
|
|
int numKeys = keys.size();
|
|
|
|
std::vector<Status> statList(numKeys);
|
|
|
|
values->resize(numKeys);
|
|
|
|
|
|
|
|
// Keep track of bytes that we read for statistics-recording later
|
|
|
|
uint64_t bytesRead = 0;
|
|
|
|
|
|
|
|
// For each of the given keys, apply the entire "get" process as follows:
|
|
|
|
// First look in the memtable, then in the immutable memtable (if any).
|
|
|
|
// s is both in/out. When in, s could either be OK or MergeInProgress.
|
|
|
|
// value will contain the current merge operand in the latter case.
|
|
|
|
for(int i=0; i<numKeys; ++i) {
|
|
|
|
Status& s = statList[i];
|
|
|
|
std::string* value = &(*values)[i];
|
|
|
|
|
|
|
|
LookupKey lkey(keys[i], snapshot);
|
|
|
|
if (mem->Get(lkey, value, &s, options_)) {
|
|
|
|
// Done
|
|
|
|
} else if (imm.Get(lkey, value, &s, options_)) {
|
|
|
|
// Done
|
|
|
|
} else {
|
|
|
|
current->Get(options, lkey, value, &s, &stats, options_);
|
|
|
|
have_stat_update = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s.ok()) {
|
|
|
|
bytesRead += value->size();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Post processing (decrement reference counts and record statistics)
|
|
|
|
mutex_.Lock();
|
|
|
|
if (!options_.disable_seek_compaction &&
|
|
|
|
have_stat_update && current->UpdateStats(stats)) {
|
|
|
|
MaybeScheduleCompaction();
|
|
|
|
}
|
|
|
|
mem->Unref();
|
|
|
|
imm.UnrefAll();
|
|
|
|
current->Unref();
|
|
|
|
RecordTick(options_.statistics, NUMBER_MULTIGET_CALLS);
|
|
|
|
RecordTick(options_.statistics, NUMBER_MULTIGET_KEYS_READ, numKeys);
|
|
|
|
RecordTick(options_.statistics, NUMBER_MULTIGET_BYTES_READ, bytesRead);
|
|
|
|
|
|
|
|
return statList;
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Iterator* DBImpl::NewIterator(const ReadOptions& options) {
|
|
|
|
SequenceNumber latest_snapshot;
|
|
|
|
Iterator* internal_iter = NewInternalIterator(options, &latest_snapshot);
|
2011-05-21 04:17:43 +02:00
|
|
|
return NewDBIterator(
|
2013-03-21 23:59:47 +01:00
|
|
|
&dbname_, env_, options_, user_comparator(), internal_iter,
|
2013-02-15 20:53:17 +01:00
|
|
|
(options.snapshot != nullptr
|
2011-05-21 04:17:43 +02:00
|
|
|
? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_
|
|
|
|
: latest_snapshot));
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
const Snapshot* DBImpl::GetSnapshot() {
|
|
|
|
MutexLock l(&mutex_);
|
2011-04-12 21:38:58 +02:00
|
|
|
return snapshots_.New(versions_->LastSequence());
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::ReleaseSnapshot(const Snapshot* s) {
|
|
|
|
MutexLock l(&mutex_);
|
2011-05-21 04:17:43 +02:00
|
|
|
snapshots_.Delete(reinterpret_cast<const SnapshotImpl*>(s));
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Convenience methods
|
|
|
|
Status DBImpl::Put(const WriteOptions& o, const Slice& key, const Slice& val) {
|
|
|
|
return DB::Put(o, key, val);
|
|
|
|
}
|
|
|
|
|
2013-03-21 23:59:47 +01:00
|
|
|
Status DBImpl::Merge(const WriteOptions& o, const Slice& key,
|
|
|
|
const Slice& val) {
|
|
|
|
if (!options_.merge_operator) {
|
|
|
|
return Status::NotSupported("Provide a merge_operator when opening DB");
|
|
|
|
} else {
|
|
|
|
return DB::Merge(o, key, val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DBImpl::Delete(const WriteOptions& options, const Slice& key) {
|
|
|
|
return DB::Delete(options, key);
|
|
|
|
}
|
|
|
|
|
2012-03-09 01:23:21 +01:00
|
|
|
Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
|
|
|
|
Writer w(&mutex_);
|
|
|
|
w.batch = my_batch;
|
|
|
|
w.sync = options.sync;
|
2012-07-05 22:39:28 +02:00
|
|
|
w.disableWAL = options.disableWAL;
|
2012-03-09 01:23:21 +01:00
|
|
|
w.done = false;
|
2011-09-01 21:08:02 +02:00
|
|
|
|
2013-05-17 19:55:34 +02:00
|
|
|
StopWatch sw(env_, options_.statistics, DB_WRITE);
|
2013-03-26 02:01:47 +01:00
|
|
|
MutexLock l(&mutex_);
|
2012-03-09 01:23:21 +01:00
|
|
|
writers_.push_back(&w);
|
|
|
|
while (!w.done && &w != writers_.front()) {
|
|
|
|
w.cv.Wait();
|
|
|
|
}
|
|
|
|
if (w.done) {
|
|
|
|
return w.status;
|
|
|
|
}
|
|
|
|
|
|
|
|
// May temporarily unlock and wait.
|
2013-02-15 20:53:17 +01:00
|
|
|
Status status = MakeRoomForWrite(my_batch == nullptr);
|
2011-04-21 00:48:11 +02:00
|
|
|
uint64_t last_sequence = versions_->LastSequence();
|
2012-03-09 01:23:21 +01:00
|
|
|
Writer* last_writer = &w;
|
2013-02-15 20:53:17 +01:00
|
|
|
if (status.ok() && my_batch != nullptr) { // nullptr batch is for compactions
|
2012-03-09 01:23:21 +01:00
|
|
|
WriteBatch* updates = BuildBatchGroup(&last_writer);
|
2013-03-04 19:44:04 +01:00
|
|
|
const SequenceNumber current_sequence = last_sequence + 1;
|
|
|
|
WriteBatchInternal::SetSequence(updates, current_sequence);
|
2013-01-16 01:48:22 +01:00
|
|
|
int my_batch_count = WriteBatchInternal::Count(updates);
|
|
|
|
last_sequence += my_batch_count;
|
|
|
|
// Record statistics
|
|
|
|
RecordTick(options_.statistics, NUMBER_KEYS_WRITTEN, my_batch_count);
|
2013-02-21 04:22:13 +01:00
|
|
|
RecordTick(options_.statistics,
|
|
|
|
BYTES_WRITTEN,
|
|
|
|
WriteBatchInternal::ByteSize(updates));
|
2012-03-09 01:23:21 +01:00
|
|
|
// Add to log and apply to memtable. We can release the lock
|
|
|
|
// during this phase since &w is currently responsible for logging
|
|
|
|
// and protects against concurrent loggers and concurrent writes
|
|
|
|
// into mem_.
|
2011-09-01 21:08:02 +02:00
|
|
|
{
|
|
|
|
mutex_.Unlock();
|
2012-11-06 20:21:57 +01:00
|
|
|
if (options.disableWAL) {
|
|
|
|
flush_on_destroy_ = true;
|
|
|
|
}
|
|
|
|
|
2012-07-05 22:39:28 +02:00
|
|
|
if (!options.disableWAL) {
|
|
|
|
status = log_->AddRecord(WriteBatchInternal::Contents(updates));
|
|
|
|
if (status.ok() && options.sync) {
|
2012-08-27 21:10:26 +02:00
|
|
|
if (options_.use_fsync) {
|
2013-06-05 20:06:21 +02:00
|
|
|
StopWatch(env_, options_.statistics, WAL_FILE_SYNC_MICROS);
|
2013-01-20 11:07:13 +01:00
|
|
|
status = log_->file()->Fsync();
|
2012-08-27 21:10:26 +02:00
|
|
|
} else {
|
2013-06-05 20:06:21 +02:00
|
|
|
StopWatch(env_, options_.statistics, WAL_FILE_SYNC_MICROS);
|
2013-01-20 11:07:13 +01:00
|
|
|
status = log_->file()->Sync();
|
2012-08-27 21:10:26 +02:00
|
|
|
}
|
2012-07-05 22:39:28 +02:00
|
|
|
}
|
2011-09-01 21:08:02 +02:00
|
|
|
}
|
|
|
|
if (status.ok()) {
|
|
|
|
status = WriteBatchInternal::InsertInto(updates, mem_);
|
|
|
|
}
|
|
|
|
mutex_.Lock();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2013-03-04 19:44:04 +01:00
|
|
|
last_flushed_sequence_ = current_sequence;
|
2013-03-28 23:19:28 +01:00
|
|
|
if (updates == &tmp_batch_) tmp_batch_.Clear();
|
2011-09-01 21:08:02 +02:00
|
|
|
|
|
|
|
versions_->SetLastSequence(last_sequence);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2012-03-09 01:23:21 +01:00
|
|
|
|
|
|
|
while (true) {
|
|
|
|
Writer* ready = writers_.front();
|
|
|
|
writers_.pop_front();
|
|
|
|
if (ready != &w) {
|
|
|
|
ready->status = status;
|
|
|
|
ready->done = true;
|
|
|
|
ready->cv.Signal();
|
|
|
|
}
|
|
|
|
if (ready == last_writer) break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Notify new head of write queue
|
|
|
|
if (!writers_.empty()) {
|
|
|
|
writers_.front()->cv.Signal();
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-03-09 01:23:21 +01:00
|
|
|
// REQUIRES: Writer list must be non-empty
|
2013-02-15 20:53:17 +01:00
|
|
|
// REQUIRES: First writer must have a non-nullptr batch
|
2012-03-09 01:23:21 +01:00
|
|
|
WriteBatch* DBImpl::BuildBatchGroup(Writer** last_writer) {
|
|
|
|
assert(!writers_.empty());
|
|
|
|
Writer* first = writers_.front();
|
|
|
|
WriteBatch* result = first->batch;
|
2013-02-15 20:53:17 +01:00
|
|
|
assert(result != nullptr);
|
2012-03-09 01:23:21 +01:00
|
|
|
|
|
|
|
size_t size = WriteBatchInternal::ByteSize(first->batch);
|
|
|
|
|
|
|
|
// Allow the group to grow up to a maximum size, but if the
|
|
|
|
// original write is small, limit the growth so we do not slow
|
|
|
|
// down the small write too much.
|
|
|
|
size_t max_size = 1 << 20;
|
|
|
|
if (size <= (128<<10)) {
|
|
|
|
max_size = size + (128<<10);
|
|
|
|
}
|
|
|
|
|
|
|
|
*last_writer = first;
|
|
|
|
std::deque<Writer*>::iterator iter = writers_.begin();
|
|
|
|
++iter; // Advance past "first"
|
|
|
|
for (; iter != writers_.end(); ++iter) {
|
|
|
|
Writer* w = *iter;
|
|
|
|
if (w->sync && !first->sync) {
|
|
|
|
// Do not include a sync write into a batch handled by a non-sync write.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-07-05 22:39:28 +02:00
|
|
|
if (!w->disableWAL && first->disableWAL) {
|
|
|
|
// Do not include a write that needs WAL into a batch that has
|
|
|
|
// WAL disabled.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (w->batch != nullptr) {
|
2012-03-09 01:23:21 +01:00
|
|
|
size += WriteBatchInternal::ByteSize(w->batch);
|
|
|
|
if (size > max_size) {
|
|
|
|
// Do not make batch too big
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Append to *reuslt
|
|
|
|
if (result == first->batch) {
|
|
|
|
// Switch to temporary batch instead of disturbing caller's batch
|
2013-03-28 23:19:28 +01:00
|
|
|
result = &tmp_batch_;
|
2012-03-09 01:23:21 +01:00
|
|
|
assert(WriteBatchInternal::Count(result) == 0);
|
|
|
|
WriteBatchInternal::Append(result, first->batch);
|
|
|
|
}
|
|
|
|
WriteBatchInternal::Append(result, w->batch);
|
|
|
|
}
|
|
|
|
*last_writer = w;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-09-01 21:08:02 +02:00
|
|
|
// REQUIRES: mutex_ is held
|
2012-03-09 01:23:21 +01:00
|
|
|
// REQUIRES: this thread is currently at the front of the writer queue
|
2011-04-12 21:38:58 +02:00
|
|
|
Status DBImpl::MakeRoomForWrite(bool force) {
|
|
|
|
mutex_.AssertHeld();
|
2012-03-09 01:23:21 +01:00
|
|
|
assert(!writers_.empty());
|
2011-05-21 04:17:43 +02:00
|
|
|
bool allow_delay = !force;
|
2013-03-02 21:56:04 +01:00
|
|
|
bool allow_rate_limit_delay = !force;
|
|
|
|
uint64_t rate_limit_delay_millis = 0;
|
2011-04-12 21:38:58 +02:00
|
|
|
Status s;
|
2012-10-26 22:37:21 +02:00
|
|
|
double score;
|
2012-06-23 04:30:03 +02:00
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
while (true) {
|
|
|
|
if (!bg_error_.ok()) {
|
|
|
|
// Yield previous error
|
|
|
|
s = bg_error_;
|
|
|
|
break;
|
2011-05-21 04:17:43 +02:00
|
|
|
} else if (
|
|
|
|
allow_delay &&
|
2012-06-23 04:30:03 +02:00
|
|
|
versions_->NumLevelFiles(0) >=
|
2012-11-27 06:16:21 +01:00
|
|
|
options_.level0_slowdown_writes_trigger) {
|
2011-05-21 04:17:43 +02:00
|
|
|
// We are getting close to hitting a hard limit on the number of
|
|
|
|
// L0 files. Rather than delaying a single write by several
|
|
|
|
// seconds when we hit the hard limit, start delaying each
|
|
|
|
// individual write by 1ms to reduce latency variance. Also,
|
|
|
|
// this delay hands over some CPU to the compaction thread in
|
|
|
|
// case it is sharing the same core as the writer.
|
|
|
|
mutex_.Unlock();
|
2012-10-29 20:04:27 +01:00
|
|
|
uint64_t t1 = env_->NowMicros();
|
2011-05-21 04:17:43 +02:00
|
|
|
env_->SleepForMicroseconds(1000);
|
2012-10-29 20:04:27 +01:00
|
|
|
uint64_t delayed = env_->NowMicros() - t1;
|
2013-05-10 23:41:45 +02:00
|
|
|
RecordTick(options_.statistics, STALL_L0_SLOWDOWN_MICROS, delayed);
|
2012-10-29 20:04:27 +01:00
|
|
|
stall_level0_slowdown_ += delayed;
|
2011-05-21 04:17:43 +02:00
|
|
|
allow_delay = false; // Do not delay a single write more than once
|
2012-11-05 18:41:38 +01:00
|
|
|
//Log(options_.info_log,
|
|
|
|
// "delaying write %llu usecs for level0_slowdown_writes_trigger\n",
|
2012-11-08 00:11:37 +01:00
|
|
|
// (long long unsigned int)delayed);
|
2011-05-21 04:17:43 +02:00
|
|
|
mutex_.Lock();
|
2012-10-19 23:00:53 +02:00
|
|
|
delayed_writes_++;
|
2011-04-12 21:38:58 +02:00
|
|
|
} else if (!force &&
|
|
|
|
(mem_->ApproximateMemoryUsage() <= options_.write_buffer_size)) {
|
|
|
|
// There is room in current memtable
|
2012-10-19 23:00:53 +02:00
|
|
|
if (allow_delay) {
|
|
|
|
DelayLoggingAndReset();
|
|
|
|
}
|
2011-04-12 21:38:58 +02:00
|
|
|
break;
|
2012-10-19 23:00:53 +02:00
|
|
|
} else if (imm_.size() == options_.max_write_buffer_number - 1) {
|
2011-04-12 21:38:58 +02:00
|
|
|
// We have filled up the current memtable, but the previous
|
2012-10-19 23:00:53 +02:00
|
|
|
// ones are still being compacted, so we wait.
|
|
|
|
DelayLoggingAndReset();
|
2012-08-23 01:57:51 +02:00
|
|
|
Log(options_.info_log, "wait for memtable compaction...\n");
|
2012-10-23 19:34:09 +02:00
|
|
|
uint64_t t1 = env_->NowMicros();
|
2011-06-07 16:40:26 +02:00
|
|
|
bg_cv_.Wait();
|
2013-05-10 23:41:45 +02:00
|
|
|
const uint64_t stall = env_->NowMicros() -t1;
|
|
|
|
RecordTick(options_.statistics, STALL_MEMTABLE_COMPACTION_MICROS, stall);
|
|
|
|
stall_memtable_compaction_ += stall;
|
2012-06-23 04:30:03 +02:00
|
|
|
} else if (versions_->NumLevelFiles(0) >=
|
2012-11-27 06:16:21 +01:00
|
|
|
options_.level0_stop_writes_trigger) {
|
2011-05-21 04:17:43 +02:00
|
|
|
// There are too many level-0 files.
|
2012-10-19 23:00:53 +02:00
|
|
|
DelayLoggingAndReset();
|
2012-10-23 19:34:09 +02:00
|
|
|
uint64_t t1 = env_->NowMicros();
|
2012-10-19 23:00:53 +02:00
|
|
|
Log(options_.info_log, "wait for fewer level0 files...\n");
|
2011-06-07 16:40:26 +02:00
|
|
|
bg_cv_.Wait();
|
2013-05-10 23:41:45 +02:00
|
|
|
const uint64_t stall = env_->NowMicros() - t1;
|
|
|
|
RecordTick(options_.statistics, STALL_L0_NUM_FILES_MICROS, stall);
|
|
|
|
stall_level0_num_files_ += stall;
|
2012-10-26 22:37:21 +02:00
|
|
|
} else if (
|
2013-03-02 21:56:04 +01:00
|
|
|
allow_rate_limit_delay &&
|
2012-10-26 22:37:21 +02:00
|
|
|
options_.rate_limit > 1.0 &&
|
|
|
|
(score = versions_->MaxCompactionScore()) > options_.rate_limit) {
|
|
|
|
// Delay a write when the compaction score for any level is too large.
|
2013-03-02 21:56:04 +01:00
|
|
|
int max_level = versions_->MaxCompactionScoreLevel();
|
2012-10-26 22:37:21 +02:00
|
|
|
mutex_.Unlock();
|
2012-10-29 20:04:27 +01:00
|
|
|
uint64_t t1 = env_->NowMicros();
|
2012-10-26 22:37:21 +02:00
|
|
|
env_->SleepForMicroseconds(1000);
|
2012-10-29 20:04:27 +01:00
|
|
|
uint64_t delayed = env_->NowMicros() - t1;
|
2013-03-02 21:56:04 +01:00
|
|
|
stall_leveln_slowdown_[max_level] += delayed;
|
|
|
|
// Make sure the following value doesn't round to zero.
|
2013-05-10 23:41:45 +02:00
|
|
|
uint64_t rate_limit = std::max((delayed / 1000), (uint64_t) 1);
|
|
|
|
rate_limit_delay_millis += rate_limit;
|
|
|
|
RecordTick(options_.statistics, RATE_LIMIT_DELAY_MILLIS, rate_limit);
|
2013-03-15 02:32:01 +01:00
|
|
|
if (rate_limit_delay_millis >=
|
|
|
|
(unsigned)options_.rate_limit_delay_milliseconds) {
|
2013-03-02 21:56:04 +01:00
|
|
|
allow_rate_limit_delay = false;
|
|
|
|
}
|
|
|
|
// Log(options_.info_log,
|
|
|
|
// "delaying write %llu usecs for rate limits with max score %.2f\n",
|
|
|
|
// (long long unsigned int)delayed, score);
|
2012-10-26 22:37:21 +02:00
|
|
|
mutex_.Lock();
|
2011-04-12 21:38:58 +02:00
|
|
|
} else {
|
|
|
|
// Attempt to switch to a new memtable and trigger compaction of old
|
2012-10-19 23:00:53 +02:00
|
|
|
DelayLoggingAndReset();
|
2011-04-12 21:38:58 +02:00
|
|
|
assert(versions_->PrevLogNumber() == 0);
|
|
|
|
uint64_t new_log_number = versions_->NewFileNumber();
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<WritableFile> lfile;
|
2013-06-08 00:35:17 +02:00
|
|
|
EnvOptions soptions(storage_options_);
|
|
|
|
soptions.use_mmap_writes = false;
|
2013-03-28 21:13:35 +01:00
|
|
|
s = env_->NewWritableFile(
|
|
|
|
LogFileName(dbname_, new_log_number),
|
|
|
|
&lfile,
|
|
|
|
soptions
|
|
|
|
);
|
2011-04-12 21:38:58 +02:00
|
|
|
if (!s.ok()) {
|
2012-08-27 08:45:35 +02:00
|
|
|
// Avoid chewing through file number space in a tight loop.
|
2013-01-20 11:07:13 +01:00
|
|
|
versions_->ReuseFileNumber(new_log_number);
|
2011-04-12 21:38:58 +02:00
|
|
|
break;
|
|
|
|
}
|
2013-01-15 23:05:42 +01:00
|
|
|
// Our final size should be less than write_buffer_size
|
|
|
|
// (compression, etc) but err on the side of caution.
|
|
|
|
lfile->SetPreallocationBlockSize(1.1 * options_.write_buffer_size);
|
2011-06-22 04:36:45 +02:00
|
|
|
logfile_number_ = new_log_number;
|
2013-01-20 11:07:13 +01:00
|
|
|
log_.reset(new log::Writer(std::move(lfile)));
|
2013-06-11 23:23:58 +02:00
|
|
|
mem_->SetLogNumber(logfile_number_);
|
2012-10-19 23:00:53 +02:00
|
|
|
imm_.Add(mem_);
|
|
|
|
mem_ = new MemTable(internal_comparator_, NumberLevels());
|
2011-05-21 04:17:43 +02:00
|
|
|
mem_->Ref();
|
2011-04-12 21:38:58 +02:00
|
|
|
force = false; // Do not force another compaction if have room
|
|
|
|
MaybeScheduleCompaction();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool DBImpl::GetProperty(const Slice& property, std::string* value) {
|
|
|
|
value->clear();
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
MutexLock l(&mutex_);
|
|
|
|
Slice in = property;
|
|
|
|
Slice prefix("leveldb.");
|
|
|
|
if (!in.starts_with(prefix)) return false;
|
|
|
|
in.remove_prefix(prefix.size());
|
|
|
|
|
|
|
|
if (in.starts_with("num-files-at-level")) {
|
|
|
|
in.remove_prefix(strlen("num-files-at-level"));
|
|
|
|
uint64_t level;
|
|
|
|
bool ok = ConsumeDecimalNumber(&in, &level) && in.empty();
|
2012-08-29 21:29:43 +02:00
|
|
|
if (!ok || (int)level >= NumberLevels()) {
|
2011-03-18 23:37:00 +01:00
|
|
|
return false;
|
|
|
|
} else {
|
2011-04-12 21:38:58 +02:00
|
|
|
char buf[100];
|
2011-04-21 00:48:11 +02:00
|
|
|
snprintf(buf, sizeof(buf), "%d",
|
|
|
|
versions_->NumLevelFiles(static_cast<int>(level)));
|
2011-04-12 21:38:58 +02:00
|
|
|
*value = buf;
|
2011-03-18 23:37:00 +01:00
|
|
|
return true;
|
|
|
|
}
|
2013-03-19 14:36:03 +01:00
|
|
|
} else if (in == "levelstats") {
|
|
|
|
char buf[1000];
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Level Files Size(MB)\n"
|
|
|
|
"--------------------\n");
|
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
for (int level = 0; level < NumberLevels(); level++) {
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"%3d %8d %8.0f\n",
|
|
|
|
level,
|
|
|
|
versions_->NumLevelFiles(level),
|
|
|
|
versions_->NumLevelBytes(level) / 1048576.0);
|
|
|
|
value->append(buf);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
} else if (in == "stats") {
|
2012-10-23 19:34:09 +02:00
|
|
|
char buf[1000];
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
uint64_t total_bytes_written = 0;
|
|
|
|
uint64_t total_bytes_read = 0;
|
2012-10-23 19:34:09 +02:00
|
|
|
uint64_t micros_up = env_->NowMicros() - started_at_;
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
// Add "+1" to make sure seconds_up is > 0 and avoid NaN later
|
|
|
|
double seconds_up = (micros_up + 1) / 1000000.0;
|
2013-03-02 21:56:04 +01:00
|
|
|
uint64_t total_slowdown = 0;
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
uint64_t interval_bytes_written = 0;
|
|
|
|
uint64_t interval_bytes_read = 0;
|
|
|
|
uint64_t interval_bytes_new = 0;
|
|
|
|
double interval_seconds_up = 0;
|
2012-10-23 19:34:09 +02:00
|
|
|
|
|
|
|
// Pardon the long line but I think it is easier to read this way.
|
2011-04-12 21:38:58 +02:00
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
" Compactions\n"
|
2013-05-31 07:57:22 +02:00
|
|
|
"Level Files Size(MB) Score Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall\n"
|
|
|
|
"----------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
|
2011-04-12 21:38:58 +02:00
|
|
|
);
|
|
|
|
value->append(buf);
|
2012-06-23 04:30:03 +02:00
|
|
|
for (int level = 0; level < NumberLevels(); level++) {
|
2011-04-12 21:38:58 +02:00
|
|
|
int files = versions_->NumLevelFiles(level);
|
|
|
|
if (stats_[level].micros > 0 || files > 0) {
|
2012-10-23 19:34:09 +02:00
|
|
|
int64_t bytes_read = stats_[level].bytes_readn +
|
|
|
|
stats_[level].bytes_readnp1;
|
|
|
|
int64_t bytes_new = stats_[level].bytes_written -
|
|
|
|
stats_[level].bytes_readnp1;
|
|
|
|
double amplify = (stats_[level].bytes_readn == 0)
|
|
|
|
? 0.0
|
|
|
|
: (stats_[level].bytes_written + stats_[level].bytes_readnp1) /
|
|
|
|
(double) stats_[level].bytes_readn;
|
|
|
|
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
total_bytes_read += bytes_read;
|
|
|
|
total_bytes_written += stats_[level].bytes_written;
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
snprintf(
|
|
|
|
buf, sizeof(buf),
|
2013-05-31 07:57:22 +02:00
|
|
|
"%3d %8d %8.0f %5.1f %9.0f %9.0f %9.0f %9.0f %9.0f %9.0f %7.1f %9.1f %11.1f %8d %8d %8d %8d %8d %9.1f\n",
|
2011-04-12 21:38:58 +02:00
|
|
|
level,
|
|
|
|
files,
|
|
|
|
versions_->NumLevelBytes(level) / 1048576.0,
|
2013-05-31 07:57:22 +02:00
|
|
|
versions_->NumLevelBytes(level) /
|
|
|
|
versions_->MaxBytesForLevel(level),
|
2011-04-12 21:38:58 +02:00
|
|
|
stats_[level].micros / 1e6,
|
2012-10-23 19:34:09 +02:00
|
|
|
bytes_read / 1048576.0,
|
|
|
|
stats_[level].bytes_written / 1048576.0,
|
|
|
|
stats_[level].bytes_readn / 1048576.0,
|
|
|
|
stats_[level].bytes_readnp1 / 1048576.0,
|
|
|
|
bytes_new / 1048576.0,
|
|
|
|
amplify,
|
2013-03-19 14:36:03 +01:00
|
|
|
// +1 to avoid division by 0
|
|
|
|
(bytes_read / 1048576.0) / ((stats_[level].micros+1) / 1000000.0),
|
2012-10-26 22:00:42 +02:00
|
|
|
(stats_[level].bytes_written / 1048576.0) /
|
2013-03-19 14:36:03 +01:00
|
|
|
((stats_[level].micros+1) / 1000000.0),
|
2012-10-23 19:34:09 +02:00
|
|
|
stats_[level].files_in_leveln,
|
|
|
|
stats_[level].files_in_levelnp1,
|
|
|
|
stats_[level].files_out_levelnp1,
|
|
|
|
stats_[level].files_out_levelnp1 - stats_[level].files_in_levelnp1,
|
2013-03-02 21:56:04 +01:00
|
|
|
stats_[level].count,
|
|
|
|
stall_leveln_slowdown_[level] / 1000000.0);
|
|
|
|
total_slowdown += stall_leveln_slowdown_[level];
|
2011-04-12 21:38:58 +02:00
|
|
|
value->append(buf);
|
|
|
|
}
|
|
|
|
}
|
2012-10-23 19:34:09 +02:00
|
|
|
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
interval_bytes_new = stats_[0].bytes_written - last_stats_.bytes_new_;
|
|
|
|
interval_bytes_read = total_bytes_read - last_stats_.bytes_read_;
|
|
|
|
interval_bytes_written = total_bytes_written - last_stats_.bytes_written_;
|
|
|
|
interval_seconds_up = seconds_up - last_stats_.seconds_up_;
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",
|
|
|
|
seconds_up, interval_seconds_up);
|
|
|
|
value->append(buf);
|
|
|
|
|
2012-10-23 19:34:09 +02:00
|
|
|
snprintf(buf, sizeof(buf),
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
"Compaction IO cumulative (GB): "
|
|
|
|
"%.2f new, %.2f read, %.2f write, %.2f read+write\n",
|
2012-10-23 19:34:09 +02:00
|
|
|
stats_[0].bytes_written / (1048576.0 * 1024),
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
total_bytes_read / (1048576.0 * 1024),
|
|
|
|
total_bytes_written / (1048576.0 * 1024),
|
|
|
|
(total_bytes_read + total_bytes_written) / (1048576.0 * 1024));
|
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Compaction IO cumulative (MB/sec): "
|
|
|
|
"%.1f new, %.1f read, %.1f write, %.1f read+write\n",
|
2012-10-29 18:29:08 +01:00
|
|
|
stats_[0].bytes_written / 1048576.0 / seconds_up,
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
total_bytes_read / 1048576.0 / seconds_up,
|
|
|
|
total_bytes_written / 1048576.0 / seconds_up,
|
|
|
|
(total_bytes_read + total_bytes_written) / 1048576.0 / seconds_up);
|
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
// +1 to avoid divide by 0 and NaN
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Amplification cumulative: %.1f write, %.1f compaction\n",
|
|
|
|
(double) total_bytes_written / (stats_[0].bytes_written+1),
|
|
|
|
(double) (total_bytes_written + total_bytes_read)
|
|
|
|
/ (stats_[0].bytes_written+1));
|
2012-10-23 19:34:09 +02:00
|
|
|
value->append(buf);
|
|
|
|
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Compaction IO interval (MB): "
|
|
|
|
"%.2f new, %.2f read, %.2f write, %.2f read+write\n",
|
|
|
|
interval_bytes_new / 1048576.0,
|
|
|
|
interval_bytes_read/ 1048576.0,
|
|
|
|
interval_bytes_written / 1048576.0,
|
|
|
|
(interval_bytes_read + interval_bytes_written) / 1048576.0);
|
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Compaction IO interval (MB/sec): "
|
|
|
|
"%.1f new, %.1f read, %.1f write, %.1f read+write\n",
|
|
|
|
interval_bytes_new / 1048576.0 / interval_seconds_up,
|
|
|
|
interval_bytes_read / 1048576.0 / interval_seconds_up,
|
|
|
|
interval_bytes_written / 1048576.0 / interval_seconds_up,
|
|
|
|
(interval_bytes_read + interval_bytes_written)
|
|
|
|
/ 1048576.0 / interval_seconds_up);
|
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
// +1 to avoid divide by 0 and NaN
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Amplification interval: %.1f write, %.1f compaction\n",
|
|
|
|
(double) interval_bytes_written / (interval_bytes_new+1),
|
|
|
|
(double) (interval_bytes_written + interval_bytes_read) /
|
|
|
|
(interval_bytes_new+1));
|
2012-10-23 19:34:09 +02:00
|
|
|
value->append(buf);
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Stalls(secs): %.3f level0_slowdown, %.3f level0_numfiles, "
|
2012-10-26 22:37:21 +02:00
|
|
|
"%.3f memtable_compaction, %.3f leveln_slowdown\n",
|
2012-10-23 19:34:09 +02:00
|
|
|
stall_level0_slowdown_ / 1000000.0,
|
|
|
|
stall_level0_num_files_ / 1000000.0,
|
2012-10-26 22:37:21 +02:00
|
|
|
stall_memtable_compaction_ / 1000000.0,
|
2013-03-02 21:56:04 +01:00
|
|
|
total_slowdown / 1000000.0);
|
2012-10-23 19:34:09 +02:00
|
|
|
value->append(buf);
|
|
|
|
|
Improve output for GetProperty('leveldb.stats')
Summary:
Display separate values for read, write & total compaction IO.
Display compaction amplification and write amplification.
Add similar values for the period since the last call to GetProperty. Results since the server started
are reported as "cumulative" stats. Results since the last call to GetProperty are reported as
"interval" stats.
Level Files Size(MB) Time(sec) Read(MB) Write(MB) Rn(MB) Rnp1(MB) Wnew(MB) Amplify Read(MB/s) Write(MB/s) Rn Rnp1 Wnp1 NewW Count Ln-stall
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 7 13 21 0 211 0 0 211 0.0 0.0 10.1 0 0 0 0 113 0.0
1 79 157 88 993 989 198 795 194 9.0 11.3 11.2 106 405 502 97 14 0.0
2 19 36 5 63 63 37 27 36 2.4 12.3 12.2 19 14 32 18 12 0.0
>>>>>>>>>>>>>>>>>>>>>>>>> text below has been is new and/or reformatted
Uptime(secs): 122.2 total, 0.9 interval
Compaction IO cumulative (GB): 0.21 new, 1.03 read, 1.23 write, 2.26 read+write
Compaction IO cumulative (MB/sec): 1.7 new, 8.6 read, 10.3 write, 19.0 read+write
Amplification cumulative: 6.0 write, 11.0 compaction
Compaction IO interval (MB): 5.59 new, 0.00 read, 5.59 write, 5.59 read+write
Compaction IO interval (MB/sec): 6.5 new, 0.0 read, 6.5 write, 6.5 read+write
Amplification interval: 1.0 write, 1.0 compaction
>>>>>>>>>>>>>>>>>>>>>>>> text above is new and/or reformatted
Stalls(secs): 90.574 level0_slowdown, 0.000 level0_numfiles, 10.165 memtable_compaction, 0.000 leveln_slowdown
Task ID: #
Blame Rev:
Test Plan:
make check, run db_bench
Revert Plan:
Database Impact:
Memcache Impact:
Other Notes:
EImportant:
- begin *PUBLIC* platform impact section -
Bugzilla: #
- end platform impact -
Reviewers: haobo
Reviewed By: haobo
CC: leveldb
Differential Revision: https://reviews.facebook.net/D11049
2013-06-03 17:16:16 +02:00
|
|
|
last_stats_.bytes_read_ = total_bytes_read;
|
|
|
|
last_stats_.bytes_written_ = total_bytes_written;
|
|
|
|
last_stats_.bytes_new_ = stats_[0].bytes_written;
|
|
|
|
last_stats_.seconds_up_ = seconds_up;
|
|
|
|
|
2011-04-12 21:38:58 +02:00
|
|
|
return true;
|
2011-10-06 01:30:28 +02:00
|
|
|
} else if (in == "sstables") {
|
|
|
|
*value = versions_->current()->DebugString();
|
|
|
|
return true;
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
2011-04-12 21:38:58 +02:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DBImpl::GetApproximateSizes(
|
|
|
|
const Range* range, int n,
|
|
|
|
uint64_t* sizes) {
|
|
|
|
// TODO(opt): better implementation
|
|
|
|
Version* v;
|
|
|
|
{
|
|
|
|
MutexLock l(&mutex_);
|
|
|
|
versions_->current()->Ref();
|
|
|
|
v = versions_->current();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < n; i++) {
|
|
|
|
// Convert user_key into a corresponding internal key.
|
|
|
|
InternalKey k1(range[i].start, kMaxSequenceNumber, kValueTypeForSeek);
|
|
|
|
InternalKey k2(range[i].limit, kMaxSequenceNumber, kValueTypeForSeek);
|
|
|
|
uint64_t start = versions_->ApproximateOffsetOf(v, k1);
|
|
|
|
uint64_t limit = versions_->ApproximateOffsetOf(v, k2);
|
|
|
|
sizes[i] = (limit >= start ? limit - start : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
MutexLock l(&mutex_);
|
|
|
|
v->Unref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 23:00:53 +02:00
|
|
|
inline void DBImpl::DelayLoggingAndReset() {
|
|
|
|
if (delayed_writes_ > 0) {
|
|
|
|
Log(options_.info_log, "delayed %d write...\n", delayed_writes_ );
|
|
|
|
delayed_writes_ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Default implementations of convenience methods that subclasses of DB
|
|
|
|
// can call if they wish
|
|
|
|
Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice& value) {
|
|
|
|
WriteBatch batch;
|
|
|
|
batch.Put(key, value);
|
|
|
|
return Write(opt, &batch);
|
|
|
|
}
|
|
|
|
|
|
|
|
Status DB::Delete(const WriteOptions& opt, const Slice& key) {
|
|
|
|
WriteBatch batch;
|
|
|
|
batch.Delete(key);
|
|
|
|
return Write(opt, &batch);
|
|
|
|
}
|
|
|
|
|
2013-03-21 23:59:47 +01:00
|
|
|
Status DB::Merge(const WriteOptions& opt, const Slice& key,
|
|
|
|
const Slice& value) {
|
|
|
|
WriteBatch batch;
|
|
|
|
batch.Merge(key, value);
|
|
|
|
return Write(opt, &batch);
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
DB::~DB() { }
|
|
|
|
|
|
|
|
Status DB::Open(const Options& options, const std::string& dbname,
|
|
|
|
DB** dbptr) {
|
2013-02-15 20:53:17 +01:00
|
|
|
*dbptr = nullptr;
|
2013-06-08 00:35:17 +02:00
|
|
|
EnvOptions soptions;
|
2011-03-18 23:37:00 +01:00
|
|
|
|
2013-02-15 20:53:17 +01:00
|
|
|
if (options.block_cache != nullptr && options.no_block_cache) {
|
2012-11-01 01:02:24 +01:00
|
|
|
return Status::InvalidArgument(
|
2013-02-15 20:53:17 +01:00
|
|
|
"no_block_cache is true while block_cache is not nullptr");
|
2012-11-01 01:02:24 +01:00
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
DBImpl* impl = new DBImpl(options, dbname);
|
2012-11-26 22:56:45 +01:00
|
|
|
Status s = impl->CreateArchivalDirectory();
|
|
|
|
if (!s.ok()) {
|
|
|
|
delete impl;
|
|
|
|
return s;
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
impl->mutex_.Lock();
|
2012-06-23 04:30:03 +02:00
|
|
|
VersionEdit edit(impl->NumberLevels());
|
2012-11-26 22:56:45 +01:00
|
|
|
s = impl->Recover(&edit); // Handles create_if_missing, error_if_exists
|
2011-03-18 23:37:00 +01:00
|
|
|
if (s.ok()) {
|
2011-04-12 21:38:58 +02:00
|
|
|
uint64_t new_log_number = impl->versions_->NewFileNumber();
|
2013-01-20 11:07:13 +01:00
|
|
|
unique_ptr<WritableFile> lfile;
|
2013-06-08 00:35:17 +02:00
|
|
|
soptions.use_mmap_writes = false;
|
2011-04-12 21:38:58 +02:00
|
|
|
s = options.env->NewWritableFile(LogFileName(dbname, new_log_number),
|
2013-03-15 01:00:04 +01:00
|
|
|
&lfile, soptions);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (s.ok()) {
|
2013-01-15 23:05:42 +01:00
|
|
|
lfile->SetPreallocationBlockSize(1.1 * options.write_buffer_size);
|
2011-04-12 21:38:58 +02:00
|
|
|
edit.SetLogNumber(new_log_number);
|
2011-06-22 04:36:45 +02:00
|
|
|
impl->logfile_number_ = new_log_number;
|
2013-01-20 11:07:13 +01:00
|
|
|
impl->log_.reset(new log::Writer(std::move(lfile)));
|
2011-09-01 21:08:02 +02:00
|
|
|
s = impl->versions_->LogAndApply(&edit, &impl->mutex_);
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
if (s.ok()) {
|
|
|
|
impl->DeleteObsoleteFiles();
|
2011-05-21 04:17:43 +02:00
|
|
|
impl->MaybeScheduleCompaction();
|
2012-08-15 00:20:36 +02:00
|
|
|
impl->MaybeScheduleLogDBDeployStats();
|
2011-03-18 23:37:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
impl->mutex_.Unlock();
|
|
|
|
if (s.ok()) {
|
|
|
|
*dbptr = impl;
|
|
|
|
} else {
|
|
|
|
delete impl;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2011-05-21 04:17:43 +02:00
|
|
|
Snapshot::~Snapshot() {
|
|
|
|
}
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
Status DestroyDB(const std::string& dbname, const Options& options) {
|
|
|
|
Env* env = options.env;
|
|
|
|
std::vector<std::string> filenames;
|
2012-12-10 20:02:07 +01:00
|
|
|
std::vector<std::string> archiveFiles;
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
// Ignore error in case directory does not exist
|
|
|
|
env->GetChildren(dbname, &filenames);
|
2012-12-10 20:02:07 +01:00
|
|
|
env->GetChildren(ArchivalDirectory(dbname), &archiveFiles);
|
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
if (filenames.empty()) {
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
|
|
|
FileLock* lock;
|
2011-07-15 02:20:57 +02:00
|
|
|
const std::string lockname = LockFileName(dbname);
|
|
|
|
Status result = env->LockFile(lockname, &lock);
|
2011-03-18 23:37:00 +01:00
|
|
|
if (result.ok()) {
|
|
|
|
uint64_t number;
|
|
|
|
FileType type;
|
2011-04-21 00:48:11 +02:00
|
|
|
for (size_t i = 0; i < filenames.size(); i++) {
|
2011-07-15 02:20:57 +02:00
|
|
|
if (ParseFileName(filenames[i], &number, &type) &&
|
2012-03-09 16:51:04 +01:00
|
|
|
type != kDBLockFile) { // Lock file will be deleted at end
|
2012-12-17 20:26:59 +01:00
|
|
|
Status del;
|
|
|
|
if (type == kMetaDatabase) {
|
|
|
|
del = DestroyDB(dbname + "/" + filenames[i], options);
|
|
|
|
} else {
|
|
|
|
del = env->DeleteFile(dbname + "/" + filenames[i]);
|
|
|
|
}
|
2011-03-18 23:37:00 +01:00
|
|
|
if (result.ok() && !del.ok()) {
|
|
|
|
result = del;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-12-10 20:02:07 +01:00
|
|
|
|
|
|
|
// Delete archival files.
|
|
|
|
for (size_t i = 0; i < archiveFiles.size(); ++i) {
|
|
|
|
ParseFileName(archiveFiles[i], &number, &type);
|
|
|
|
if (type == kLogFile) {
|
|
|
|
Status del = env->DeleteFile(ArchivalDirectory(dbname) + "/" +
|
|
|
|
archiveFiles[i]);
|
|
|
|
if (result.ok() && !del.ok()) {
|
|
|
|
result = del;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-12-14 22:21:53 +01:00
|
|
|
// ignore case where no archival directory is present.
|
|
|
|
env->DeleteDir(ArchivalDirectory(dbname));
|
2012-12-10 20:02:07 +01:00
|
|
|
|
2011-03-18 23:37:00 +01:00
|
|
|
env->UnlockFile(lock); // Ignore error since state is already gone
|
2011-07-15 02:20:57 +02:00
|
|
|
env->DeleteFile(lockname);
|
2011-03-18 23:37:00 +01:00
|
|
|
env->DeleteDir(dbname); // Ignore error in case dir contains other files
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-08-21 09:33:21 +02:00
|
|
|
//
|
|
|
|
// A global method that can dump out the build version
|
2012-09-18 22:18:32 +02:00
|
|
|
void dumpLeveldbBuildVersion(Logger * log) {
|
|
|
|
Log(log, "Git sha %s", leveldb_build_git_sha);
|
2013-01-24 20:45:11 +01:00
|
|
|
Log(log, "Compile time %s %s",
|
|
|
|
leveldb_build_compile_time, leveldb_build_compile_date);
|
2012-08-21 09:33:21 +02:00
|
|
|
}
|
|
|
|
|
2011-10-31 18:22:06 +01:00
|
|
|
} // namespace leveldb
|