df9069d23f
Summary: In this patch, try to allocate the whole iterator tree starting from DBIter from an arena 1. ArenaWrappedDBIter is created when serves as the entry point of an iterator tree, with an arena in it. 2. Add an option to create iterator from arena for following iterators: DBIter, MergingIterator, MemtableIterator, all mem table's iterators, all table reader's iterators and two level iterator. 3. MergeIteratorBuilder is created to incrementally build the tree of internal iterators. It is passed to mem table list and version set and add iterators to it. Limitations: (1) Only DB::NewIterator() without tailing uses the arena. Other cases, including readonly DB and compactions are still from malloc (2) Two level iterator itself is allocated in arena, but not iterators inside it. Test Plan: make all check Reviewers: ljin, haobo Reviewed By: haobo Subscribers: leveldb, dhruba, yhchiang, igor Differential Revision: https://reviews.facebook.net/D18513
93 lines
2.5 KiB
C++
93 lines
2.5 KiB
C++
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
// 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.
|
|
//
|
|
// 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 "rocksdb/iterator.h"
|
|
#include "table/iterator_wrapper.h"
|
|
#include "util/arena.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
Iterator::Iterator() {
|
|
cleanup_.function = nullptr;
|
|
cleanup_.next = nullptr;
|
|
}
|
|
|
|
Iterator::~Iterator() {
|
|
if (cleanup_.function != nullptr) {
|
|
(*cleanup_.function)(cleanup_.arg1, cleanup_.arg2);
|
|
for (Cleanup* c = cleanup_.next; c != nullptr; ) {
|
|
(*c->function)(c->arg1, c->arg2);
|
|
Cleanup* next = c->next;
|
|
delete c;
|
|
c = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Iterator::RegisterCleanup(CleanupFunction func, void* arg1, void* arg2) {
|
|
assert(func != nullptr);
|
|
Cleanup* c;
|
|
if (cleanup_.function == nullptr) {
|
|
c = &cleanup_;
|
|
} else {
|
|
c = new Cleanup;
|
|
c->next = cleanup_.next;
|
|
cleanup_.next = c;
|
|
}
|
|
c->function = func;
|
|
c->arg1 = arg1;
|
|
c->arg2 = arg2;
|
|
}
|
|
|
|
namespace {
|
|
class EmptyIterator : public Iterator {
|
|
public:
|
|
explicit EmptyIterator(const Status& s) : status_(s) { }
|
|
virtual bool Valid() const { return false; }
|
|
virtual void Seek(const Slice& target) { }
|
|
virtual void SeekToFirst() { }
|
|
virtual void SeekToLast() { }
|
|
virtual void Next() { assert(false); }
|
|
virtual void Prev() { assert(false); }
|
|
Slice key() const { assert(false); return Slice(); }
|
|
Slice value() const { assert(false); return Slice(); }
|
|
virtual Status status() const { return status_; }
|
|
private:
|
|
Status status_;
|
|
};
|
|
} // namespace
|
|
|
|
Iterator* NewEmptyIterator() {
|
|
return new EmptyIterator(Status::OK());
|
|
}
|
|
|
|
Iterator* NewEmptyIterator(Arena* arena) {
|
|
if (arena == nullptr) {
|
|
return NewEmptyIterator();
|
|
} else {
|
|
auto mem = arena->AllocateAligned(sizeof(EmptyIterator));
|
|
return new (mem) EmptyIterator(Status::OK());
|
|
}
|
|
}
|
|
|
|
Iterator* NewErrorIterator(const Status& status) {
|
|
return new EmptyIterator(status);
|
|
}
|
|
|
|
Iterator* NewErrorIterator(const Status& status, Arena* arena) {
|
|
if (arena == nullptr) {
|
|
return NewErrorIterator(status);
|
|
} else {
|
|
auto mem = arena->AllocateAligned(sizeof(EmptyIterator));
|
|
return new (mem) EmptyIterator(status);
|
|
}
|
|
}
|
|
|
|
} // namespace rocksdb
|