mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
74781a0c49
Summary: This patch adds three new MemTableRep's: UnsortedRep, PrefixHashRep, and VectorRep. UnsortedRep stores keys in an std::unordered_map of std::sets. When an iterator is requested, it dumps the keys into an std::set and iterates over that. VectorRep stores keys in an std::vector. When an iterator is requested, it creates a copy of the vector and sorts it using std::sort. The iterator accesses that new vector. PrefixHashRep stores keys in an unordered_map mapping prefixes to ordered sets. I also added one API change. I added a function MemTableRep::MarkImmutable. This function is called when the rep is added to the immutable list. It doesn't do anything yet, but it seems like that could be useful. In particular, for the vectorrep, it means we could elide the extra copy and just sort in place. The only reason I haven't done that yet is because the use of the ArenaAllocator complicates things (I can elaborate on this if needed). Test Plan: make -j32 check ./db_stress --memtablerep=vector ./db_stress --memtablerep=unsorted ./db_stress --memtablerep=prefixhash --prefix_size=10 Reviewers: dhruba, haobo, emayanke Reviewed By: dhruba CC: leveldb Differential Revision: https://reviews.facebook.net/D12117
100 lines
2.8 KiB
C++
100 lines
2.8 KiB
C++
#include "leveldb/memtablerep.h"
|
|
#include "db/memtable.h"
|
|
#include "db/skiplist.h"
|
|
|
|
namespace leveldb {
|
|
namespace {
|
|
class SkipListRep : public MemTableRep {
|
|
SkipList<const char*, MemTableRep::KeyComparator&> skip_list_;
|
|
public:
|
|
explicit SkipListRep(MemTableRep::KeyComparator& compare, Arena* arena)
|
|
: skip_list_(compare, arena) {
|
|
}
|
|
|
|
// Insert key into the list.
|
|
// REQUIRES: nothing that compares equal to key is currently in the list.
|
|
virtual void Insert(const char* key) override {
|
|
skip_list_.Insert(key);
|
|
}
|
|
|
|
// Returns true iff an entry that compares equal to key is in the list.
|
|
virtual bool Contains(const char* key) const override {
|
|
return skip_list_.Contains(key);
|
|
}
|
|
|
|
virtual size_t ApproximateMemoryUsage() override {
|
|
// All memory is allocated through arena; nothing to report here
|
|
return 0;
|
|
}
|
|
|
|
virtual ~SkipListRep() override { }
|
|
|
|
// Iteration over the contents of a skip list
|
|
class Iterator : public MemTableRep::Iterator {
|
|
SkipList<const char*, MemTableRep::KeyComparator&>::Iterator iter_;
|
|
public:
|
|
// Initialize an iterator over the specified list.
|
|
// The returned iterator is not valid.
|
|
explicit Iterator(
|
|
const SkipList<const char*, MemTableRep::KeyComparator&>* list
|
|
) : iter_(list) { }
|
|
|
|
virtual ~Iterator() override { }
|
|
|
|
// Returns true iff the iterator is positioned at a valid node.
|
|
virtual bool Valid() const override {
|
|
return iter_.Valid();
|
|
}
|
|
|
|
// Returns the key at the current position.
|
|
// REQUIRES: Valid()
|
|
virtual const char* key() const override {
|
|
return iter_.key();
|
|
}
|
|
|
|
// Advances to the next position.
|
|
// REQUIRES: Valid()
|
|
virtual void Next() override {
|
|
iter_.Next();
|
|
}
|
|
|
|
// Advances to the previous position.
|
|
// REQUIRES: Valid()
|
|
virtual void Prev() override {
|
|
iter_.Prev();
|
|
}
|
|
|
|
// Advance to the first entry with a key >= target
|
|
virtual void Seek(const char* target) override {
|
|
iter_.Seek(target);
|
|
}
|
|
|
|
// Position at the first entry in list.
|
|
// Final state of iterator is Valid() iff list is not empty.
|
|
virtual void SeekToFirst() override {
|
|
iter_.SeekToFirst();
|
|
}
|
|
|
|
// Position at the last entry in list.
|
|
// Final state of iterator is Valid() iff list is not empty.
|
|
virtual void SeekToLast() override {
|
|
iter_.SeekToLast();
|
|
}
|
|
};
|
|
|
|
// Unhide default implementations of GetIterator
|
|
using MemTableRep::GetIterator;
|
|
|
|
virtual std::shared_ptr<MemTableRep::Iterator> GetIterator() override {
|
|
return std::make_shared<SkipListRep::Iterator>(&skip_list_);
|
|
}
|
|
};
|
|
}
|
|
|
|
std::shared_ptr<MemTableRep> SkipListFactory::CreateMemTableRep (
|
|
MemTableRep::KeyComparator& compare, Arena* arena) {
|
|
return std::shared_ptr<MemTableRep>(new SkipListRep(compare, arena));
|
|
}
|
|
|
|
} // namespace leveldb
|