2016-02-10 00:12:00 +01:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2014-05-30 23:31:55 +02:00
|
|
|
// This source code is licensed under the BSD-style license found in the
|
|
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
|
|
|
|
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
#include "db/forward_iterator.h"
|
|
|
|
|
2014-08-29 23:32:37 +02:00
|
|
|
#include <limits>
|
2014-05-30 23:31:55 +02:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
2014-08-29 23:32:37 +02:00
|
|
|
|
2016-03-01 03:38:03 +01:00
|
|
|
#include "db/column_family.h"
|
2014-05-30 23:31:55 +02:00
|
|
|
#include "db/db_impl.h"
|
|
|
|
#include "db/db_iter.h"
|
2016-03-01 03:38:03 +01:00
|
|
|
#include "db/dbformat.h"
|
|
|
|
#include "db/job_context.h"
|
2014-05-30 23:31:55 +02:00
|
|
|
#include "rocksdb/env.h"
|
|
|
|
#include "rocksdb/slice.h"
|
|
|
|
#include "rocksdb/slice_transform.h"
|
|
|
|
#include "table/merger.h"
|
2016-03-01 03:38:03 +01:00
|
|
|
#include "util/string_util.h"
|
2015-08-25 22:40:58 +02:00
|
|
|
#include "util/sync_point.h"
|
2014-05-30 23:31:55 +02:00
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
// Usage:
|
|
|
|
// LevelIterator iter;
|
|
|
|
// iter.SetFileIndex(file_index);
|
|
|
|
// iter.Seek(target);
|
|
|
|
// iter.Next()
|
2015-10-13 00:06:38 +02:00
|
|
|
class LevelIterator : public InternalIterator {
|
2014-05-30 23:31:55 +02:00
|
|
|
public:
|
|
|
|
LevelIterator(const ColumnFamilyData* const cfd,
|
|
|
|
const ReadOptions& read_options,
|
|
|
|
const std::vector<FileMetaData*>& files)
|
|
|
|
: cfd_(cfd), read_options_(read_options), files_(files), valid_(false),
|
|
|
|
file_index_(std::numeric_limits<uint32_t>::max()) {}
|
|
|
|
|
|
|
|
void SetFileIndex(uint32_t file_index) {
|
|
|
|
assert(file_index < files_.size());
|
|
|
|
if (file_index != file_index_) {
|
|
|
|
file_index_ = file_index;
|
2014-08-29 23:32:37 +02:00
|
|
|
Reset();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
valid_ = false;
|
|
|
|
}
|
2014-08-29 23:32:37 +02:00
|
|
|
void Reset() {
|
|
|
|
assert(file_index_ < files_.size());
|
|
|
|
file_iter_.reset(cfd_->table_cache()->NewIterator(
|
|
|
|
read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
|
Measure file read latency histogram per level
Summary: In internal stats, remember read latency histogram, if statistics is enabled. It can be retrieved from DB::GetProperty() with "rocksdb.dbstats" property, if it is enabled.
Test Plan: Manually run db_bench and prints out "rocksdb.dbstats" by hand and make sure it prints out as expected
Reviewers: igor, IslamAbdelRahman, rven, kradhakrishnan, anthony, yhchiang
Reviewed By: yhchiang
Subscribers: MarkCallaghan, leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D44193
2015-08-13 23:35:54 +02:00
|
|
|
files_[file_index_]->fd, nullptr /* table_reader_ptr */, nullptr,
|
|
|
|
false));
|
2014-08-29 23:32:37 +02:00
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
void SeekToLast() override {
|
|
|
|
status_ = Status::NotSupported("LevelIterator::SeekToLast()");
|
|
|
|
valid_ = false;
|
|
|
|
}
|
2015-02-26 20:28:41 +01:00
|
|
|
void Prev() override {
|
2014-05-30 23:31:55 +02:00
|
|
|
status_ = Status::NotSupported("LevelIterator::Prev()");
|
|
|
|
valid_ = false;
|
|
|
|
}
|
|
|
|
bool Valid() const override {
|
|
|
|
return valid_;
|
|
|
|
}
|
|
|
|
void SeekToFirst() override {
|
|
|
|
SetFileIndex(0);
|
|
|
|
file_iter_->SeekToFirst();
|
|
|
|
valid_ = file_iter_->Valid();
|
|
|
|
}
|
|
|
|
void Seek(const Slice& internal_key) override {
|
|
|
|
assert(file_iter_ != nullptr);
|
|
|
|
file_iter_->Seek(internal_key);
|
|
|
|
valid_ = file_iter_->Valid();
|
|
|
|
}
|
|
|
|
void Next() override {
|
|
|
|
assert(valid_);
|
|
|
|
file_iter_->Next();
|
2014-08-29 23:32:37 +02:00
|
|
|
for (;;) {
|
|
|
|
if (file_iter_->status().IsIncomplete() || file_iter_->Valid()) {
|
|
|
|
valid_ = !file_iter_->status().IsIncomplete();
|
|
|
|
return;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
if (file_index_ + 1 >= files_.size()) {
|
|
|
|
valid_ = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SetFileIndex(file_index_ + 1);
|
|
|
|
file_iter_->SeekToFirst();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Slice key() const override {
|
|
|
|
assert(valid_);
|
|
|
|
return file_iter_->key();
|
|
|
|
}
|
|
|
|
Slice value() const override {
|
|
|
|
assert(valid_);
|
|
|
|
return file_iter_->value();
|
|
|
|
}
|
|
|
|
Status status() const override {
|
2014-07-10 02:46:18 +02:00
|
|
|
if (!status_.ok()) {
|
|
|
|
return status_;
|
|
|
|
} else if (file_iter_ && !file_iter_->status().ok()) {
|
|
|
|
return file_iter_->status();
|
|
|
|
}
|
|
|
|
return Status::OK();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
const ColumnFamilyData* const cfd_;
|
|
|
|
const ReadOptions& read_options_;
|
|
|
|
const std::vector<FileMetaData*>& files_;
|
|
|
|
|
|
|
|
bool valid_;
|
|
|
|
uint32_t file_index_;
|
|
|
|
Status status_;
|
2015-10-13 00:06:38 +02:00
|
|
|
std::unique_ptr<InternalIterator> file_iter_;
|
2014-05-30 23:31:55 +02:00
|
|
|
};
|
|
|
|
|
2014-06-03 21:28:58 +02:00
|
|
|
ForwardIterator::ForwardIterator(DBImpl* db, const ReadOptions& read_options,
|
2015-08-20 01:05:51 +02:00
|
|
|
ColumnFamilyData* cfd,
|
|
|
|
SuperVersion* current_sv)
|
2014-05-30 23:31:55 +02:00
|
|
|
: db_(db),
|
|
|
|
read_options_(read_options),
|
|
|
|
cfd_(cfd),
|
2014-11-18 19:20:10 +01:00
|
|
|
prefix_extractor_(cfd->ioptions()->prefix_extractor),
|
2014-05-30 23:31:55 +02:00
|
|
|
user_comparator_(cfd->user_comparator()),
|
|
|
|
immutable_min_heap_(MinIterComparator(&cfd_->internal_comparator())),
|
2014-10-24 00:34:21 +02:00
|
|
|
sv_(current_sv),
|
2014-05-30 23:31:55 +02:00
|
|
|
mutable_iter_(nullptr),
|
|
|
|
current_(nullptr),
|
2015-09-01 01:44:34 +02:00
|
|
|
valid_(false),
|
2014-09-26 23:20:24 +02:00
|
|
|
status_(Status::OK()),
|
|
|
|
immutable_status_(Status::OK()),
|
2015-08-20 01:05:51 +02:00
|
|
|
has_iter_trimmed_for_upper_bound_(false),
|
2015-09-01 01:44:34 +02:00
|
|
|
current_over_upper_bound_(false),
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
is_prev_set_(false),
|
2014-10-24 00:34:21 +02:00
|
|
|
is_prev_inclusive_(false) {
|
|
|
|
if (sv_) {
|
|
|
|
RebuildIterators(false);
|
|
|
|
}
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
|
|
|
|
ForwardIterator::~ForwardIterator() {
|
2014-10-24 00:34:21 +02:00
|
|
|
Cleanup(true);
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
void ForwardIterator::SVCleanup() {
|
|
|
|
if (sv_ != nullptr && sv_->Unref()) {
|
|
|
|
// Job id == 0 means that this is not our background process, but rather
|
|
|
|
// user thread
|
|
|
|
JobContext job_context(0);
|
|
|
|
db_->mutex_.Lock();
|
|
|
|
sv_->Cleanup();
|
|
|
|
db_->FindObsoleteFiles(&job_context, false, true);
|
2016-08-04 02:42:06 +02:00
|
|
|
if (read_options_.background_purge_on_iterator_cleanup) {
|
|
|
|
db_->ScheduleBgLogWriterClose(&job_context);
|
|
|
|
}
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
db_->mutex_.Unlock();
|
|
|
|
delete sv_;
|
|
|
|
if (job_context.HaveSomethingToDelete()) {
|
2016-08-04 02:42:06 +02:00
|
|
|
db_->PurgeObsoleteFiles(
|
|
|
|
job_context, read_options_.background_purge_on_iterator_cleanup);
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
}
|
|
|
|
job_context.Clean();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-24 00:34:21 +02:00
|
|
|
void ForwardIterator::Cleanup(bool release_sv) {
|
2014-09-05 02:40:41 +02:00
|
|
|
if (mutable_iter_ != nullptr) {
|
2015-10-13 00:06:38 +02:00
|
|
|
mutable_iter_->~InternalIterator();
|
2014-09-05 02:40:41 +02:00
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
for (auto* m : imm_iters_) {
|
2015-10-13 00:06:38 +02:00
|
|
|
m->~InternalIterator();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
imm_iters_.clear();
|
|
|
|
for (auto* f : l0_iters_) {
|
|
|
|
delete f;
|
|
|
|
}
|
|
|
|
l0_iters_.clear();
|
|
|
|
for (auto* l : level_iters_) {
|
|
|
|
delete l;
|
|
|
|
}
|
|
|
|
level_iters_.clear();
|
|
|
|
|
2014-10-24 00:34:21 +02:00
|
|
|
if (release_sv) {
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
SVCleanup();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ForwardIterator::Valid() const {
|
2015-09-01 01:44:34 +02:00
|
|
|
// See UpdateCurrent().
|
|
|
|
return valid_ ? !current_over_upper_bound_ : false;
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ForwardIterator::SeekToFirst() {
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
if (sv_ == nullptr) {
|
2014-10-24 00:34:21 +02:00
|
|
|
RebuildIterators(true);
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
} else if (sv_->version_number != cfd_->GetSuperVersionNumber()) {
|
|
|
|
RenewIterators();
|
2014-09-26 23:20:24 +02:00
|
|
|
} else if (immutable_status_.IsIncomplete()) {
|
2014-08-29 23:32:37 +02:00
|
|
|
ResetIncompleteIterators();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
SeekInternal(Slice(), true);
|
|
|
|
}
|
|
|
|
|
2015-08-20 01:05:51 +02:00
|
|
|
bool ForwardIterator::IsOverUpperBound(const Slice& internal_key) const {
|
|
|
|
return !(read_options_.iterate_upper_bound == nullptr ||
|
|
|
|
cfd_->internal_comparator().user_comparator()->Compare(
|
|
|
|
ExtractUserKey(internal_key),
|
|
|
|
*read_options_.iterate_upper_bound) < 0);
|
|
|
|
}
|
|
|
|
|
2014-05-30 23:31:55 +02:00
|
|
|
void ForwardIterator::Seek(const Slice& internal_key) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (IsOverUpperBound(internal_key)) {
|
|
|
|
valid_ = false;
|
|
|
|
}
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
if (sv_ == nullptr) {
|
2014-10-24 00:34:21 +02:00
|
|
|
RebuildIterators(true);
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
} else if (sv_->version_number != cfd_->GetSuperVersionNumber()) {
|
|
|
|
RenewIterators();
|
2014-09-26 23:20:24 +02:00
|
|
|
} else if (immutable_status_.IsIncomplete()) {
|
2014-08-29 23:32:37 +02:00
|
|
|
ResetIncompleteIterators();
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
SeekInternal(internal_key, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForwardIterator::SeekInternal(const Slice& internal_key,
|
|
|
|
bool seek_to_first) {
|
2014-10-24 00:34:21 +02:00
|
|
|
assert(mutable_iter_);
|
2014-05-30 23:31:55 +02:00
|
|
|
// mutable
|
|
|
|
seek_to_first ? mutable_iter_->SeekToFirst() :
|
|
|
|
mutable_iter_->Seek(internal_key);
|
|
|
|
|
|
|
|
// immutable
|
|
|
|
// TODO(ljin): NeedToSeekImmutable has negative impact on performance
|
|
|
|
// if it turns to need to seek immutable often. We probably want to have
|
|
|
|
// an option to turn it off.
|
|
|
|
if (seek_to_first || NeedToSeekImmutable(internal_key)) {
|
2014-09-26 23:20:24 +02:00
|
|
|
immutable_status_ = Status::OK();
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
if ((has_iter_trimmed_for_upper_bound_) &&
|
|
|
|
(cfd_->internal_comparator().InternalKeyComparator::Compare(
|
|
|
|
prev_key_.GetKey(), internal_key) > 0)) {
|
2015-08-20 01:05:51 +02:00
|
|
|
// Some iterators are trimmed. Need to rebuild.
|
|
|
|
RebuildIterators(true);
|
|
|
|
// Already seeked mutable iter, so seek again
|
|
|
|
seek_to_first ? mutable_iter_->SeekToFirst()
|
|
|
|
: mutable_iter_->Seek(internal_key);
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
{
|
|
|
|
auto tmp = MinIterHeap(MinIterComparator(&cfd_->internal_comparator()));
|
|
|
|
immutable_min_heap_.swap(tmp);
|
|
|
|
}
|
2015-08-20 01:05:51 +02:00
|
|
|
for (size_t i = 0; i < imm_iters_.size(); i++) {
|
|
|
|
auto* m = imm_iters_[i];
|
2014-05-30 23:31:55 +02:00
|
|
|
seek_to_first ? m->SeekToFirst() : m->Seek(internal_key);
|
2014-09-26 23:20:24 +02:00
|
|
|
if (!m->status().ok()) {
|
|
|
|
immutable_status_ = m->status();
|
|
|
|
} else if (m->Valid()) {
|
2015-08-28 20:07:07 +02:00
|
|
|
immutable_min_heap_.push(m);
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-08 20:40:42 +02:00
|
|
|
Slice user_key;
|
|
|
|
if (!seek_to_first) {
|
|
|
|
user_key = ExtractUserKey(internal_key);
|
|
|
|
}
|
2014-10-31 16:48:19 +01:00
|
|
|
const VersionStorageInfo* vstorage = sv_->current->storage_info();
|
2014-10-27 23:49:46 +01:00
|
|
|
const std::vector<FileMetaData*>& l0 = vstorage->LevelFiles(0);
|
2015-12-16 00:26:20 +01:00
|
|
|
for (size_t i = 0; i < l0.size(); ++i) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (!l0_iters_[i]) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
if (seek_to_first) {
|
|
|
|
l0_iters_[i]->SeekToFirst();
|
|
|
|
} else {
|
|
|
|
// If the target key passes over the larget key, we are sure Next()
|
|
|
|
// won't go over this file.
|
2014-07-08 20:40:42 +02:00
|
|
|
if (user_comparator_->Compare(user_key,
|
2014-10-28 18:08:41 +01:00
|
|
|
l0[i]->largest.user_key()) > 0) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (read_options_.iterate_upper_bound != nullptr) {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
delete l0_iters_[i];
|
|
|
|
l0_iters_[i] = nullptr;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
l0_iters_[i]->Seek(internal_key);
|
|
|
|
}
|
2014-08-29 23:32:37 +02:00
|
|
|
|
2014-09-26 23:20:24 +02:00
|
|
|
if (!l0_iters_[i]->status().ok()) {
|
|
|
|
immutable_status_ = l0_iters_[i]->status();
|
2014-08-29 23:32:37 +02:00
|
|
|
} else if (l0_iters_[i]->Valid()) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (!IsOverUpperBound(l0_iters_[i]->key())) {
|
|
|
|
immutable_min_heap_.push(l0_iters_[i]);
|
|
|
|
} else {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
delete l0_iters_[i];
|
|
|
|
l0_iters_[i] = nullptr;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-08 20:40:42 +02:00
|
|
|
|
|
|
|
int32_t search_left_bound = 0;
|
|
|
|
int32_t search_right_bound = FileIndexer::kLevelMaxIndex;
|
2014-11-04 02:45:55 +01:00
|
|
|
for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
|
2014-10-28 18:08:41 +01:00
|
|
|
const std::vector<FileMetaData*>& level_files =
|
2014-10-27 23:49:46 +01:00
|
|
|
vstorage->LevelFiles(level);
|
2014-10-28 18:08:41 +01:00
|
|
|
if (level_files.empty()) {
|
2014-07-08 20:40:42 +02:00
|
|
|
search_left_bound = 0;
|
|
|
|
search_right_bound = FileIndexer::kLevelMaxIndex;
|
2014-05-30 23:31:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
2015-08-20 01:05:51 +02:00
|
|
|
if (level_iters_[level - 1] == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
uint32_t f_idx = 0;
|
2014-11-04 02:45:55 +01:00
|
|
|
const auto& indexer = vstorage->file_indexer();
|
2014-05-30 23:31:55 +02:00
|
|
|
if (!seek_to_first) {
|
2014-07-08 20:40:42 +02:00
|
|
|
if (search_left_bound == search_right_bound) {
|
|
|
|
f_idx = search_left_bound;
|
|
|
|
} else if (search_left_bound < search_right_bound) {
|
2014-11-11 22:47:22 +01:00
|
|
|
f_idx =
|
|
|
|
FindFileInRange(level_files, internal_key, search_left_bound,
|
|
|
|
search_right_bound == FileIndexer::kLevelMaxIndex
|
|
|
|
? static_cast<uint32_t>(level_files.size())
|
|
|
|
: search_right_bound);
|
2014-07-08 20:40:42 +02:00
|
|
|
} else {
|
|
|
|
// search_left_bound > search_right_bound
|
|
|
|
// There are only 2 cases this can happen:
|
|
|
|
// (1) target key is smaller than left most file
|
|
|
|
// (2) target key is larger than right most file
|
2014-10-28 18:08:41 +01:00
|
|
|
assert(search_left_bound == (int32_t)level_files.size() ||
|
2014-07-08 20:40:42 +02:00
|
|
|
search_right_bound == -1);
|
|
|
|
if (search_right_bound == -1) {
|
|
|
|
assert(search_left_bound == 0);
|
|
|
|
f_idx = 0;
|
|
|
|
} else {
|
2014-10-28 18:08:41 +01:00
|
|
|
indexer.GetNextLevelIndex(
|
|
|
|
level, level_files.size() - 1,
|
2014-07-08 20:40:42 +02:00
|
|
|
1, 1, &search_left_bound, &search_right_bound);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prepare hints for the next level
|
2014-10-28 18:08:41 +01:00
|
|
|
if (f_idx < level_files.size()) {
|
2014-07-08 20:40:42 +02:00
|
|
|
int cmp_smallest = user_comparator_->Compare(
|
2014-10-28 18:08:41 +01:00
|
|
|
user_key, level_files[f_idx]->smallest.user_key());
|
2015-09-08 18:47:54 +02:00
|
|
|
assert(user_comparator_->Compare(
|
2015-09-09 02:15:11 +02:00
|
|
|
user_key, level_files[f_idx]->largest.user_key()) <= 0);
|
2015-09-08 18:47:54 +02:00
|
|
|
indexer.GetNextLevelIndex(level, f_idx, cmp_smallest, -1,
|
|
|
|
&search_left_bound, &search_right_bound);
|
2014-07-08 20:40:42 +02:00
|
|
|
} else {
|
2014-10-28 18:08:41 +01:00
|
|
|
indexer.GetNextLevelIndex(
|
|
|
|
level, level_files.size() - 1,
|
2014-07-08 20:40:42 +02:00
|
|
|
1, 1, &search_left_bound, &search_right_bound);
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
2014-07-08 20:40:42 +02:00
|
|
|
|
|
|
|
// Seek
|
2014-10-28 18:08:41 +01:00
|
|
|
if (f_idx < level_files.size()) {
|
2014-05-30 23:31:55 +02:00
|
|
|
level_iters_[level - 1]->SetFileIndex(f_idx);
|
|
|
|
seek_to_first ? level_iters_[level - 1]->SeekToFirst() :
|
|
|
|
level_iters_[level - 1]->Seek(internal_key);
|
2014-08-29 23:32:37 +02:00
|
|
|
|
2014-09-26 23:20:24 +02:00
|
|
|
if (!level_iters_[level - 1]->status().ok()) {
|
|
|
|
immutable_status_ = level_iters_[level - 1]->status();
|
2014-08-29 23:32:37 +02:00
|
|
|
} else if (level_iters_[level - 1]->Valid()) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (!IsOverUpperBound(level_iters_[level - 1]->key())) {
|
|
|
|
immutable_min_heap_.push(level_iters_[level - 1]);
|
|
|
|
} else {
|
|
|
|
// Nothing in this level is interesting. Remove.
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
delete level_iters_[level - 1];
|
|
|
|
level_iters_[level - 1] = nullptr;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
if (seek_to_first) {
|
2014-05-30 23:31:55 +02:00
|
|
|
is_prev_set_ = false;
|
|
|
|
} else {
|
|
|
|
prev_key_.SetKey(internal_key);
|
|
|
|
is_prev_set_ = true;
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
is_prev_inclusive_ = true;
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
2015-09-01 01:44:34 +02:00
|
|
|
|
|
|
|
TEST_SYNC_POINT_CALLBACK("ForwardIterator::SeekInternal:Immutable", this);
|
ForwardIterator seek bugfix
Summary:
If `NeedToSeekImmutable()` returns false, `SeekInternal()` won't reset the
contents of `immutable_min_heap_`. However, since it calls `UpdateCurrent()`
unconditionally, if `current_` is one of immutable iterators (previously popped
from `immutable_min_heap_`), `UpdateCurrent()` will overwrite it. As a result,
if old `current_` in fact pointed to the smallest entry, forward iterator will
skip some records.
Fix implemented in this diff pushes `current_` back to `immutable_min_heap_`
before calling `UpdateCurrent()`.
Test Plan:
New unit test (courtesy of @lovro):
$ ROCKSDB_TESTS=TailingIteratorSeekToSame ./db_test
Reviewers: igor, dhruba, haobo, ljin
Reviewed By: ljin
Subscribers: lovro, leveldb
Differential Revision: https://reviews.facebook.net/D19653
2014-07-11 00:14:24 +02:00
|
|
|
} else if (current_ && current_ != mutable_iter_) {
|
|
|
|
// current_ is one of immutable iterators, push it back to the heap
|
|
|
|
immutable_min_heap_.push(current_);
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
UpdateCurrent();
|
2015-08-25 22:40:58 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK("ForwardIterator::SeekInternal:Return", this);
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ForwardIterator::Next() {
|
|
|
|
assert(valid_);
|
2015-08-18 23:40:06 +02:00
|
|
|
bool update_prev_key = false;
|
2014-05-30 23:31:55 +02:00
|
|
|
|
|
|
|
if (sv_ == nullptr ||
|
2014-08-29 23:32:37 +02:00
|
|
|
sv_->version_number != cfd_->GetSuperVersionNumber()) {
|
2014-05-30 23:31:55 +02:00
|
|
|
std::string current_key = key().ToString();
|
|
|
|
Slice old_key(current_key.data(), current_key.size());
|
|
|
|
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
if (sv_ == nullptr) {
|
|
|
|
RebuildIterators(true);
|
|
|
|
} else {
|
|
|
|
RenewIterators();
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
SeekInternal(old_key, false);
|
|
|
|
if (!valid_ || key().compare(old_key) != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (current_ != mutable_iter_) {
|
|
|
|
// It is going to advance immutable iterator
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
|
|
|
|
if (is_prev_set_ && prefix_extractor_) {
|
|
|
|
// advance prev_key_ to current_ only if they share the same prefix
|
|
|
|
update_prev_key =
|
|
|
|
prefix_extractor_->Transform(prev_key_.GetKey()).compare(
|
|
|
|
prefix_extractor_->Transform(current_->key())) == 0;
|
2015-08-18 23:40:06 +02:00
|
|
|
} else {
|
|
|
|
update_prev_key = true;
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
}
|
|
|
|
|
2015-08-18 23:40:06 +02:00
|
|
|
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
if (update_prev_key) {
|
|
|
|
prev_key_.SetKey(current_->key());
|
|
|
|
is_prev_set_ = true;
|
|
|
|
is_prev_inclusive_ = false;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
current_->Next();
|
2014-08-29 23:32:37 +02:00
|
|
|
if (current_ != mutable_iter_) {
|
2014-09-26 23:20:24 +02:00
|
|
|
if (!current_->status().ok()) {
|
|
|
|
immutable_status_ = current_->status();
|
2015-08-20 01:05:51 +02:00
|
|
|
} else if ((current_->Valid()) && (!IsOverUpperBound(current_->key()))) {
|
2014-08-29 23:32:37 +02:00
|
|
|
immutable_min_heap_.push(current_);
|
2015-08-20 01:05:51 +02:00
|
|
|
} else {
|
|
|
|
if ((current_->Valid()) && (IsOverUpperBound(current_->key()))) {
|
|
|
|
// remove the current iterator
|
|
|
|
DeleteCurrentIter();
|
|
|
|
current_ = nullptr;
|
|
|
|
}
|
2015-09-04 23:28:45 +02:00
|
|
|
if (update_prev_key) {
|
2015-08-18 23:40:06 +02:00
|
|
|
mutable_iter_->Seek(prev_key_.GetKey());
|
2015-08-20 01:05:51 +02:00
|
|
|
}
|
2014-08-29 23:32:37 +02:00
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
UpdateCurrent();
|
2015-08-25 22:40:58 +02:00
|
|
|
TEST_SYNC_POINT_CALLBACK("ForwardIterator::Next:Return", this);
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Slice ForwardIterator::key() const {
|
|
|
|
assert(valid_);
|
|
|
|
return current_->key();
|
|
|
|
}
|
|
|
|
|
|
|
|
Slice ForwardIterator::value() const {
|
|
|
|
assert(valid_);
|
|
|
|
return current_->value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Status ForwardIterator::status() const {
|
|
|
|
if (!status_.ok()) {
|
|
|
|
return status_;
|
|
|
|
} else if (!mutable_iter_->status().ok()) {
|
|
|
|
return mutable_iter_->status();
|
|
|
|
}
|
2014-07-10 02:46:18 +02:00
|
|
|
|
2014-09-26 23:20:24 +02:00
|
|
|
return immutable_status_;
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
2016-03-01 03:38:03 +01:00
|
|
|
Status ForwardIterator::GetProperty(std::string prop_name, std::string* prop) {
|
|
|
|
assert(prop != nullptr);
|
2016-03-03 22:18:56 +01:00
|
|
|
if (prop_name == "rocksdb.iterator.super-version-number") {
|
2016-03-01 03:38:03 +01:00
|
|
|
*prop = ToString(sv_->version_number);
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
return Status::InvalidArgument();
|
|
|
|
}
|
|
|
|
|
2014-10-24 00:34:21 +02:00
|
|
|
void ForwardIterator::RebuildIterators(bool refresh_sv) {
|
2014-05-30 23:31:55 +02:00
|
|
|
// Clean up
|
2014-10-24 00:34:21 +02:00
|
|
|
Cleanup(refresh_sv);
|
|
|
|
if (refresh_sv) {
|
|
|
|
// New
|
|
|
|
sv_ = cfd_->GetReferencedSuperVersion(&(db_->mutex_));
|
|
|
|
}
|
2014-09-05 02:40:41 +02:00
|
|
|
mutable_iter_ = sv_->mem->NewIterator(read_options_, &arena_);
|
|
|
|
sv_->imm->AddIterators(read_options_, &imm_iters_, &arena_);
|
2015-08-25 22:40:58 +02:00
|
|
|
has_iter_trimmed_for_upper_bound_ = false;
|
2014-10-27 23:49:46 +01:00
|
|
|
|
2014-10-31 16:48:19 +01:00
|
|
|
const auto* vstorage = sv_->current->storage_info();
|
2014-10-27 23:49:46 +01:00
|
|
|
const auto& l0_files = vstorage->LevelFiles(0);
|
2014-05-30 23:31:55 +02:00
|
|
|
l0_iters_.reserve(l0_files.size());
|
|
|
|
for (const auto* l0 : l0_files) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if ((read_options_.iterate_upper_bound != nullptr) &&
|
|
|
|
cfd_->internal_comparator().user_comparator()->Compare(
|
|
|
|
l0->smallest.user_key(), *read_options_.iterate_upper_bound) > 0) {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
l0_iters_.push_back(nullptr);
|
|
|
|
continue;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
l0_iters_.push_back(cfd_->table_cache()->NewIterator(
|
2014-06-14 00:54:19 +02:00
|
|
|
read_options_, *cfd_->soptions(), cfd_->internal_comparator(), l0->fd));
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
BuildLevelIterators(vstorage);
|
|
|
|
current_ = nullptr;
|
|
|
|
is_prev_set_ = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForwardIterator::RenewIterators() {
|
|
|
|
SuperVersion* svnew;
|
|
|
|
assert(sv_);
|
|
|
|
svnew = cfd_->GetReferencedSuperVersion(&(db_->mutex_));
|
|
|
|
|
|
|
|
if (mutable_iter_ != nullptr) {
|
|
|
|
mutable_iter_->~InternalIterator();
|
|
|
|
}
|
|
|
|
for (auto* m : imm_iters_) {
|
|
|
|
m->~InternalIterator();
|
|
|
|
}
|
|
|
|
imm_iters_.clear();
|
|
|
|
|
|
|
|
mutable_iter_ = svnew->mem->NewIterator(read_options_, &arena_);
|
|
|
|
svnew->imm->AddIterators(read_options_, &imm_iters_, &arena_);
|
|
|
|
|
|
|
|
const auto* vstorage = sv_->current->storage_info();
|
|
|
|
const auto& l0_files = vstorage->LevelFiles(0);
|
|
|
|
const auto* vstorage_new = svnew->current->storage_info();
|
|
|
|
const auto& l0_files_new = vstorage_new->LevelFiles(0);
|
2015-12-16 00:26:20 +01:00
|
|
|
size_t iold, inew;
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
bool found;
|
|
|
|
std::vector<InternalIterator*> l0_iters_new;
|
|
|
|
l0_iters_new.reserve(l0_files_new.size());
|
|
|
|
|
|
|
|
for (inew = 0; inew < l0_files_new.size(); inew++) {
|
|
|
|
found = false;
|
|
|
|
for (iold = 0; iold < l0_files.size(); iold++) {
|
|
|
|
if (l0_files[iold] == l0_files_new[inew]) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found) {
|
|
|
|
if (l0_iters_[iold] == nullptr) {
|
|
|
|
l0_iters_new.push_back(nullptr);
|
|
|
|
TEST_SYNC_POINT_CALLBACK("ForwardIterator::RenewIterators:Null", this);
|
|
|
|
} else {
|
|
|
|
l0_iters_new.push_back(l0_iters_[iold]);
|
|
|
|
l0_iters_[iold] = nullptr;
|
|
|
|
TEST_SYNC_POINT_CALLBACK("ForwardIterator::RenewIterators:Copy", this);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
l0_iters_new.push_back(cfd_->table_cache()->NewIterator(
|
|
|
|
read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
|
|
|
|
l0_files_new[inew]->fd));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto* f : l0_iters_) {
|
|
|
|
delete f;
|
|
|
|
}
|
|
|
|
l0_iters_.clear();
|
|
|
|
l0_iters_ = l0_iters_new;
|
|
|
|
|
|
|
|
for (auto* l : level_iters_) {
|
|
|
|
delete l;
|
|
|
|
}
|
2015-11-17 19:27:51 +01:00
|
|
|
level_iters_.clear();
|
Reuse file iterators in tailing iterator when memtable is flushed
Summary:
Under a tailing workload, there were increased block cache
misses when a memtable was flushed because we were rebuilding iterators
in that case since the version set changed. This was exacerbated in the
case of iterate_upper_bound, since file iterators which were over the
iterate_upper_bound would have been deleted and are now brought back as
part of the Rebuild, only to be deleted again. We now renew the iterators
and only build iterators for files which are added and delete file
iterators for files which are deleted.
Refer to https://reviews.facebook.net/D50463 for previous version
Test Plan: DBTestTailingIterator.TailingIteratorTrimSeekToNext
Reviewers: anthony, IslamAbdelRahman, igor, tnovak, yhchiang, sdong
Reviewed By: sdong
Subscribers: yhchiang, march, dhruba, leveldb, lovro
Differential Revision: https://reviews.facebook.net/D50679
2015-11-14 00:50:59 +01:00
|
|
|
BuildLevelIterators(vstorage_new);
|
|
|
|
current_ = nullptr;
|
|
|
|
is_prev_set_ = false;
|
|
|
|
SVCleanup();
|
|
|
|
sv_ = svnew;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ForwardIterator::BuildLevelIterators(const VersionStorageInfo* vstorage) {
|
2015-11-17 19:27:51 +01:00
|
|
|
level_iters_.reserve(vstorage->num_levels() - 1);
|
2014-11-04 02:45:55 +01:00
|
|
|
for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
|
2014-10-27 23:49:46 +01:00
|
|
|
const auto& level_files = vstorage->LevelFiles(level);
|
2015-08-20 01:05:51 +02:00
|
|
|
if ((level_files.empty()) ||
|
|
|
|
((read_options_.iterate_upper_bound != nullptr) &&
|
|
|
|
(user_comparator_->Compare(*read_options_.iterate_upper_bound,
|
|
|
|
level_files[0]->smallest.user_key()) <
|
|
|
|
0))) {
|
2015-11-17 19:27:51 +01:00
|
|
|
level_iters_.push_back(nullptr);
|
2015-08-25 22:40:58 +02:00
|
|
|
if (!level_files.empty()) {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
}
|
2014-05-30 23:31:55 +02:00
|
|
|
} else {
|
2015-11-17 19:27:51 +01:00
|
|
|
level_iters_.push_back(
|
|
|
|
new LevelIterator(cfd_, read_options_, level_files));
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-29 23:32:37 +02:00
|
|
|
void ForwardIterator::ResetIncompleteIterators() {
|
2014-10-31 16:48:19 +01:00
|
|
|
const auto& l0_files = sv_->current->storage_info()->LevelFiles(0);
|
2015-12-16 00:26:20 +01:00
|
|
|
for (size_t i = 0; i < l0_iters_.size(); ++i) {
|
2014-08-29 23:32:37 +02:00
|
|
|
assert(i < l0_files.size());
|
2015-08-25 22:38:35 +02:00
|
|
|
if (!l0_iters_[i] || !l0_iters_[i]->status().IsIncomplete()) {
|
2014-08-29 23:32:37 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
delete l0_iters_[i];
|
|
|
|
l0_iters_[i] = cfd_->table_cache()->NewIterator(
|
|
|
|
read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
|
|
|
|
l0_files[i]->fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto* level_iter : level_iters_) {
|
|
|
|
if (level_iter && level_iter->status().IsIncomplete()) {
|
|
|
|
level_iter->Reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
current_ = nullptr;
|
|
|
|
is_prev_set_ = false;
|
|
|
|
}
|
|
|
|
|
2014-05-30 23:31:55 +02:00
|
|
|
void ForwardIterator::UpdateCurrent() {
|
|
|
|
if (immutable_min_heap_.empty() && !mutable_iter_->Valid()) {
|
|
|
|
current_ = nullptr;
|
|
|
|
} else if (immutable_min_heap_.empty()) {
|
|
|
|
current_ = mutable_iter_;
|
|
|
|
} else if (!mutable_iter_->Valid()) {
|
|
|
|
current_ = immutable_min_heap_.top();
|
|
|
|
immutable_min_heap_.pop();
|
|
|
|
} else {
|
|
|
|
current_ = immutable_min_heap_.top();
|
|
|
|
assert(current_ != nullptr);
|
|
|
|
assert(current_->Valid());
|
|
|
|
int cmp = cfd_->internal_comparator().InternalKeyComparator::Compare(
|
2014-06-10 18:57:26 +02:00
|
|
|
mutable_iter_->key(), current_->key());
|
2014-05-30 23:31:55 +02:00
|
|
|
assert(cmp != 0);
|
|
|
|
if (cmp > 0) {
|
|
|
|
immutable_min_heap_.pop();
|
|
|
|
} else {
|
|
|
|
current_ = mutable_iter_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
valid_ = (current_ != nullptr);
|
|
|
|
if (!status_.ok()) {
|
|
|
|
status_ = Status::OK();
|
|
|
|
}
|
2015-09-01 01:44:34 +02:00
|
|
|
|
|
|
|
// Upper bound doesn't apply to the memtable iterator. We want Valid() to
|
|
|
|
// return false when all iterators are over iterate_upper_bound, but can't
|
|
|
|
// just set valid_ to false, as that would effectively disable the tailing
|
|
|
|
// optimization (Seek() would be called on all immutable iterators regardless
|
|
|
|
// of whether the target key is greater than prev_key_).
|
|
|
|
current_over_upper_bound_ = valid_ && IsOverUpperBound(current_->key());
|
2014-05-30 23:31:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ForwardIterator::NeedToSeekImmutable(const Slice& target) {
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
// We maintain the interval (prev_key_, immutable_min_heap_.top()->key())
|
|
|
|
// such that there are no records with keys within that range in
|
|
|
|
// immutable_min_heap_. Since immutable structures (SST files and immutable
|
|
|
|
// memtables) can't change in this version, we don't need to do a seek if
|
|
|
|
// 'target' belongs to that interval (immutable_min_heap_.top() is already
|
|
|
|
// at the correct position).
|
|
|
|
|
2014-09-26 23:20:24 +02:00
|
|
|
if (!valid_ || !current_ || !is_prev_set_ || !immutable_status_.ok()) {
|
2014-05-30 23:31:55 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
Slice prev_key = prev_key_.GetKey();
|
|
|
|
if (prefix_extractor_ && prefix_extractor_->Transform(target).compare(
|
|
|
|
prefix_extractor_->Transform(prev_key)) != 0) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (cfd_->internal_comparator().InternalKeyComparator::Compare(
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
prev_key, target) >= (is_prev_inclusive_ ? 1 : 0)) {
|
2014-05-30 23:31:55 +02:00
|
|
|
return true;
|
|
|
|
}
|
ForwardIterator: update prev_key_ only if prefix hasn't changed
Summary:
Since ForwardIterator is on a level below DBIter, the latter may call Next() on
it (e.g. in order to skip deletion markers). Since this also updates
`prev_key_`, it may prevent the Seek() optimization.
For example, assume that there's only one SST file and it contains the following
entries: 0101, 0201 (`ValueType::kTypeDeletion`, i.e. a tombstone record), 0201
(`kTypeValue`), 0202. Memtable is empty. `Seek(0102)` will result in `prev_key_`
being set to `0201` instead of `0102`, since `DBIter::Seek()` will call
`ForwardIterator::Next()` to skip record 0201. Therefore, when `Seek(0102)` is
called again, `NeedToSeekImmutable()` will return true.
This fix relies on `prefix_extractor_` to detect prefix changes. `prev_key_` is
only set to `current_->key()` as long as they have the same prefix.
I also made a small change to `NeedToSeekImmutable()` so it no longer returns
true when the db is empty (i.e. there's nothing but a memtable).
Test Plan:
$ TEST_TMPDIR=/dev/shm/rocksdbtest ROCKSDB_TESTS=TailingIterator ./db_test
Reviewers: sdong, igor, ljin
Reviewed By: ljin
Subscribers: leveldb
Differential Revision: https://reviews.facebook.net/D23823
2014-09-23 00:20:03 +02:00
|
|
|
|
|
|
|
if (immutable_min_heap_.empty() && current_ == mutable_iter_) {
|
|
|
|
// Nothing to seek on.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (cfd_->internal_comparator().InternalKeyComparator::Compare(
|
|
|
|
target, current_ == mutable_iter_ ? immutable_min_heap_.top()->key()
|
|
|
|
: current_->key()) > 0) {
|
2014-05-30 23:31:55 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-08-20 01:05:51 +02:00
|
|
|
void ForwardIterator::DeleteCurrentIter() {
|
|
|
|
const VersionStorageInfo* vstorage = sv_->current->storage_info();
|
|
|
|
const std::vector<FileMetaData*>& l0 = vstorage->LevelFiles(0);
|
2015-12-16 00:26:20 +01:00
|
|
|
for (size_t i = 0; i < l0.size(); ++i) {
|
2015-08-20 01:05:51 +02:00
|
|
|
if (!l0_iters_[i]) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (l0_iters_[i] == current_) {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
delete l0_iters_[i];
|
|
|
|
l0_iters_[i] = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
|
|
|
|
if (level_iters_[level - 1] == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (level_iters_[level - 1] == current_) {
|
|
|
|
has_iter_trimmed_for_upper_bound_ = true;
|
|
|
|
delete level_iters_[level - 1];
|
|
|
|
level_iters_[level - 1] = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-04 23:28:45 +02:00
|
|
|
bool ForwardIterator::TEST_CheckDeletedIters(int* pdeleted_iters,
|
|
|
|
int* pnum_iters) {
|
|
|
|
bool retval = false;
|
|
|
|
int deleted_iters = 0;
|
|
|
|
int num_iters = 0;
|
2015-08-25 22:40:58 +02:00
|
|
|
|
|
|
|
const VersionStorageInfo* vstorage = sv_->current->storage_info();
|
|
|
|
const std::vector<FileMetaData*>& l0 = vstorage->LevelFiles(0);
|
2015-12-16 00:26:20 +01:00
|
|
|
for (size_t i = 0; i < l0.size(); ++i) {
|
2015-08-25 22:40:58 +02:00
|
|
|
if (!l0_iters_[i]) {
|
2015-09-04 23:28:45 +02:00
|
|
|
retval = true;
|
|
|
|
deleted_iters++;
|
|
|
|
} else {
|
|
|
|
num_iters++;
|
2015-08-25 22:40:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int32_t level = 1; level < vstorage->num_levels(); ++level) {
|
|
|
|
if ((level_iters_[level - 1] == nullptr) &&
|
|
|
|
(!vstorage->LevelFiles(level).empty())) {
|
2015-09-04 23:28:45 +02:00
|
|
|
retval = true;
|
|
|
|
deleted_iters++;
|
|
|
|
} else if (!vstorage->LevelFiles(level).empty()) {
|
|
|
|
num_iters++;
|
2015-08-25 22:40:58 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-04 23:28:45 +02:00
|
|
|
if ((!retval) && num_iters <= 1) {
|
|
|
|
retval = true;
|
|
|
|
}
|
|
|
|
if (pdeleted_iters) {
|
|
|
|
*pdeleted_iters = deleted_iters;
|
|
|
|
}
|
|
|
|
if (pnum_iters) {
|
|
|
|
*pnum_iters = num_iters;
|
|
|
|
}
|
|
|
|
return retval;
|
2015-08-25 22:40:58 +02:00
|
|
|
}
|
2015-09-04 23:28:45 +02:00
|
|
|
|
2014-05-30 23:31:55 +02:00
|
|
|
uint32_t ForwardIterator::FindFileInRange(
|
|
|
|
const std::vector<FileMetaData*>& files, const Slice& internal_key,
|
|
|
|
uint32_t left, uint32_t right) {
|
|
|
|
while (left < right) {
|
|
|
|
uint32_t mid = (left + right) / 2;
|
|
|
|
const FileMetaData* f = files[mid];
|
|
|
|
if (cfd_->internal_comparator().InternalKeyComparator::Compare(
|
|
|
|
f->largest.Encode(), internal_key) < 0) {
|
|
|
|
// Key at "mid.largest" is < "target". Therefore all
|
|
|
|
// files at or before "mid" are uninteresting.
|
|
|
|
left = mid + 1;
|
|
|
|
} else {
|
|
|
|
// Key at "mid.largest" is >= "target". Therefore all files
|
|
|
|
// after "mid" are uninteresting.
|
|
|
|
right = mid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return right;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace rocksdb
|
|
|
|
|
|
|
|
#endif // ROCKSDB_LITE
|