Remove cuckoo hash memtable (#4953)
Summary: Cuckoo Hash is less useful than we initially expected. Remove it. Pull Request resolved: https://github.com/facebook/rocksdb/pull/4953 Differential Revision: D13979264 Pulled By: siying fbshipit-source-id: 2a60afdaa989f045357398b43a1cc5d46f4492edmain
Siying Dong
6 years ago
committed by
Facebook Github Bot
parent
199fabc197
commit
cf3a671733
@ -1,661 +0,0 @@ |
|||||||
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
||||||
// This source code is licensed under both the GPLv2 (found in the
|
|
||||||
// COPYING file in the root directory) and Apache 2.0 License
|
|
||||||
// (found in the LICENSE.Apache file in the root directory).
|
|
||||||
//
|
|
||||||
|
|
||||||
#ifndef ROCKSDB_LITE |
|
||||||
#include "memtable/hash_cuckoo_rep.h" |
|
||||||
|
|
||||||
#include <algorithm> |
|
||||||
#include <atomic> |
|
||||||
#include <limits> |
|
||||||
#include <memory> |
|
||||||
#include <queue> |
|
||||||
#include <string> |
|
||||||
#include <vector> |
|
||||||
|
|
||||||
#include "db/memtable.h" |
|
||||||
#include "memtable/skiplist.h" |
|
||||||
#include "memtable/stl_wrappers.h" |
|
||||||
#include "port/port.h" |
|
||||||
#include "rocksdb/memtablerep.h" |
|
||||||
#include "util/murmurhash.h" |
|
||||||
|
|
||||||
namespace rocksdb { |
|
||||||
namespace { |
|
||||||
|
|
||||||
// the default maximum size of the cuckoo path searching queue
|
|
||||||
static const int kCuckooPathMaxSearchSteps = 100; |
|
||||||
|
|
||||||
struct CuckooStep { |
|
||||||
static const int kNullStep = -1; |
|
||||||
// the bucket id in the cuckoo array.
|
|
||||||
int bucket_id_; |
|
||||||
// index of cuckoo-step array that points to its previous step,
|
|
||||||
// -1 if it the beginning step.
|
|
||||||
int prev_step_id_; |
|
||||||
// the depth of the current step.
|
|
||||||
unsigned int depth_; |
|
||||||
|
|
||||||
CuckooStep() : bucket_id_(-1), prev_step_id_(kNullStep), depth_(1) {} |
|
||||||
|
|
||||||
CuckooStep(CuckooStep&& o) = default; |
|
||||||
|
|
||||||
CuckooStep& operator=(CuckooStep&& rhs) { |
|
||||||
bucket_id_ = std::move(rhs.bucket_id_); |
|
||||||
prev_step_id_ = std::move(rhs.prev_step_id_); |
|
||||||
depth_ = std::move(rhs.depth_); |
|
||||||
return *this; |
|
||||||
} |
|
||||||
|
|
||||||
CuckooStep(const CuckooStep&) = delete; |
|
||||||
CuckooStep& operator=(const CuckooStep&) = delete; |
|
||||||
|
|
||||||
CuckooStep(int bucket_id, int prev_step_id, int depth) |
|
||||||
: bucket_id_(bucket_id), prev_step_id_(prev_step_id), depth_(depth) {} |
|
||||||
}; |
|
||||||
|
|
||||||
class HashCuckooRep : public MemTableRep { |
|
||||||
public: |
|
||||||
explicit HashCuckooRep(const MemTableRep::KeyComparator& compare, |
|
||||||
Allocator* allocator, const size_t bucket_count, |
|
||||||
const unsigned int hash_func_count, |
|
||||||
const size_t approximate_entry_size) |
|
||||||
: MemTableRep(allocator), |
|
||||||
compare_(compare), |
|
||||||
allocator_(allocator), |
|
||||||
bucket_count_(bucket_count), |
|
||||||
approximate_entry_size_(approximate_entry_size), |
|
||||||
cuckoo_path_max_depth_(kDefaultCuckooPathMaxDepth), |
|
||||||
occupied_count_(0), |
|
||||||
hash_function_count_(hash_func_count), |
|
||||||
backup_table_(nullptr) { |
|
||||||
char* mem = reinterpret_cast<char*>( |
|
||||||
allocator_->Allocate(sizeof(std::atomic<const char*>) * bucket_count_)); |
|
||||||
cuckoo_array_ = new (mem) std::atomic<char*>[bucket_count_]; |
|
||||||
for (unsigned int bid = 0; bid < bucket_count_; ++bid) { |
|
||||||
cuckoo_array_[bid].store(nullptr, std::memory_order_relaxed); |
|
||||||
} |
|
||||||
|
|
||||||
cuckoo_path_ = reinterpret_cast<int*>( |
|
||||||
allocator_->Allocate(sizeof(int) * (cuckoo_path_max_depth_ + 1))); |
|
||||||
is_nearly_full_ = false; |
|
||||||
} |
|
||||||
|
|
||||||
// return false, indicating HashCuckooRep does not support merge operator.
|
|
||||||
virtual bool IsMergeOperatorSupported() const override { return false; } |
|
||||||
|
|
||||||
// return false, indicating HashCuckooRep does not support snapshot.
|
|
||||||
virtual bool IsSnapshotSupported() const override { return false; } |
|
||||||
|
|
||||||
// Returns true iff an entry that compares equal to key is in the collection.
|
|
||||||
virtual bool Contains(const char* internal_key) const override; |
|
||||||
|
|
||||||
virtual ~HashCuckooRep() override {} |
|
||||||
|
|
||||||
// Insert the specified key (internal_key) into the mem-table. Assertion
|
|
||||||
// fails if
|
|
||||||
// the current mem-table already contains the specified key.
|
|
||||||
virtual void Insert(KeyHandle handle) override; |
|
||||||
|
|
||||||
// This function returns bucket_count_ * approximate_entry_size_ when any
|
|
||||||
// of the followings happen to disallow further write operations:
|
|
||||||
// 1. when the fullness reaches kMaxFullnes.
|
|
||||||
// 2. when the backup_table_ is used.
|
|
||||||
//
|
|
||||||
// otherwise, this function will always return 0.
|
|
||||||
virtual size_t ApproximateMemoryUsage() override { |
|
||||||
if (is_nearly_full_) { |
|
||||||
return bucket_count_ * approximate_entry_size_; |
|
||||||
} |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
virtual void Get(const LookupKey& k, void* callback_args, |
|
||||||
bool (*callback_func)(void* arg, |
|
||||||
const char* entry)) override; |
|
||||||
|
|
||||||
class Iterator : public MemTableRep::Iterator { |
|
||||||
std::shared_ptr<std::vector<const char*>> bucket_; |
|
||||||
std::vector<const char*>::const_iterator mutable cit_; |
|
||||||
const KeyComparator& compare_; |
|
||||||
std::string tmp_; // For passing to EncodeKey
|
|
||||||
bool mutable sorted_; |
|
||||||
void DoSort() const; |
|
||||||
|
|
||||||
public: |
|
||||||
explicit Iterator(std::shared_ptr<std::vector<const char*>> bucket, |
|
||||||
const KeyComparator& compare); |
|
||||||
|
|
||||||
// Initialize an iterator over the specified collection.
|
|
||||||
// The returned iterator is not valid.
|
|
||||||
// explicit Iterator(const MemTableRep* collection);
|
|
||||||
virtual ~Iterator() override{}; |
|
||||||
|
|
||||||
// Returns true iff the iterator is positioned at a valid node.
|
|
||||||
virtual bool Valid() const override; |
|
||||||
|
|
||||||
// Returns the key at the current position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
virtual const char* key() const override; |
|
||||||
|
|
||||||
// Advances to the next position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
virtual void Next() override; |
|
||||||
|
|
||||||
// Advances to the previous position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
virtual void Prev() override; |
|
||||||
|
|
||||||
// Advance to the first entry with a key >= target
|
|
||||||
virtual void Seek(const Slice& user_key, const char* memtable_key) override; |
|
||||||
|
|
||||||
// Retreat to the last entry with a key <= target
|
|
||||||
virtual void SeekForPrev(const Slice& user_key, |
|
||||||
const char* memtable_key) override; |
|
||||||
|
|
||||||
// Position at the first entry in collection.
|
|
||||||
// Final state of iterator is Valid() iff collection is not empty.
|
|
||||||
virtual void SeekToFirst() override; |
|
||||||
|
|
||||||
// Position at the last entry in collection.
|
|
||||||
// Final state of iterator is Valid() iff collection is not empty.
|
|
||||||
virtual void SeekToLast() override; |
|
||||||
}; |
|
||||||
|
|
||||||
struct CuckooStepBuffer { |
|
||||||
CuckooStepBuffer() : write_index_(0), read_index_(0) {} |
|
||||||
~CuckooStepBuffer() {} |
|
||||||
|
|
||||||
int write_index_; |
|
||||||
int read_index_; |
|
||||||
CuckooStep steps_[kCuckooPathMaxSearchSteps]; |
|
||||||
|
|
||||||
CuckooStep& NextWriteBuffer() { return steps_[write_index_++]; } |
|
||||||
|
|
||||||
inline const CuckooStep& ReadNext() { return steps_[read_index_++]; } |
|
||||||
|
|
||||||
inline bool HasNewWrite() { return write_index_ > read_index_; } |
|
||||||
|
|
||||||
inline void reset() { |
|
||||||
write_index_ = 0; |
|
||||||
read_index_ = 0; |
|
||||||
} |
|
||||||
|
|
||||||
inline bool IsFull() { return write_index_ >= kCuckooPathMaxSearchSteps; } |
|
||||||
|
|
||||||
// returns the number of steps that has been read
|
|
||||||
inline int ReadCount() { return read_index_; } |
|
||||||
|
|
||||||
// returns the number of steps that has been written to the buffer.
|
|
||||||
inline int WriteCount() { return write_index_; } |
|
||||||
}; |
|
||||||
|
|
||||||
private: |
|
||||||
const MemTableRep::KeyComparator& compare_; |
|
||||||
// the pointer to Allocator to allocate memory, immutable after construction.
|
|
||||||
Allocator* const allocator_; |
|
||||||
// the number of hash bucket in the hash table.
|
|
||||||
const size_t bucket_count_; |
|
||||||
// approximate size of each entry
|
|
||||||
const size_t approximate_entry_size_; |
|
||||||
// the maxinum depth of the cuckoo path.
|
|
||||||
const unsigned int cuckoo_path_max_depth_; |
|
||||||
// the current number of entries in cuckoo_array_ which has been occupied.
|
|
||||||
size_t occupied_count_; |
|
||||||
// the current number of hash functions used in the cuckoo hash.
|
|
||||||
unsigned int hash_function_count_; |
|
||||||
// the backup MemTableRep to handle the case where cuckoo hash cannot find
|
|
||||||
// a vacant bucket for inserting the key of a put request.
|
|
||||||
std::shared_ptr<MemTableRep> backup_table_; |
|
||||||
// the array to store pointers, pointing to the actual data.
|
|
||||||
std::atomic<char*>* cuckoo_array_; |
|
||||||
// a buffer to store cuckoo path
|
|
||||||
int* cuckoo_path_; |
|
||||||
// a boolean flag indicating whether the fullness of bucket array
|
|
||||||
// reaches the point to make the current memtable immutable.
|
|
||||||
bool is_nearly_full_; |
|
||||||
|
|
||||||
// the default maximum depth of the cuckoo path.
|
|
||||||
static const unsigned int kDefaultCuckooPathMaxDepth = 10; |
|
||||||
|
|
||||||
CuckooStepBuffer step_buffer_; |
|
||||||
|
|
||||||
// returns the bucket id assogied to the input slice based on the
|
|
||||||
unsigned int GetHash(const Slice& slice, const int hash_func_id) const { |
|
||||||
// the seeds used in the Murmur hash to produce different hash functions.
|
|
||||||
static const int kMurmurHashSeeds[HashCuckooRepFactory::kMaxHashCount] = { |
|
||||||
545609244, 1769731426, 763324157, 13099088, 592422103, |
|
||||||
1899789565, 248369300, 1984183468, 1613664382, 1491157517}; |
|
||||||
return static_cast<unsigned int>( |
|
||||||
MurmurHash(slice.data(), static_cast<int>(slice.size()), |
|
||||||
kMurmurHashSeeds[hash_func_id]) % |
|
||||||
bucket_count_); |
|
||||||
} |
|
||||||
|
|
||||||
// A cuckoo path is a sequence of bucket ids, where each id points to a
|
|
||||||
// location of cuckoo_array_. This path describes the displacement sequence
|
|
||||||
// of entries in order to store the desired data specified by the input user
|
|
||||||
// key. The path starts from one of the locations associated with the
|
|
||||||
// specified user key and ends at a vacant space in the cuckoo array. This
|
|
||||||
// function will update the cuckoo_path.
|
|
||||||
//
|
|
||||||
// @return true if it found a cuckoo path.
|
|
||||||
bool FindCuckooPath(const char* internal_key, const Slice& user_key, |
|
||||||
int* cuckoo_path, size_t* cuckoo_path_length, |
|
||||||
int initial_hash_id = 0); |
|
||||||
|
|
||||||
// Perform quick insert by checking whether there is a vacant bucket in one
|
|
||||||
// of the possible locations of the input key. If so, then the function will
|
|
||||||
// return true and the key will be stored in that vacant bucket.
|
|
||||||
//
|
|
||||||
// This function is a helper function of FindCuckooPath that discovers the
|
|
||||||
// first possible steps of a cuckoo path. It begins by first computing
|
|
||||||
// the possible locations of the input keys (and stores them in bucket_ids.)
|
|
||||||
// Then, if one of its possible locations is vacant, then the input key will
|
|
||||||
// be stored in that vacant space and the function will return true.
|
|
||||||
// Otherwise, the function will return false indicating a complete search
|
|
||||||
// of cuckoo-path is needed.
|
|
||||||
bool QuickInsert(const char* internal_key, const Slice& user_key, |
|
||||||
int bucket_ids[], const int initial_hash_id); |
|
||||||
|
|
||||||
// Returns the pointer to the internal iterator to the buckets where buckets
|
|
||||||
// are sorted according to the user specified KeyComparator. Note that
|
|
||||||
// any insert after this function call may affect the sorted nature of
|
|
||||||
// the returned iterator.
|
|
||||||
virtual MemTableRep::Iterator* GetIterator(Arena* arena) override { |
|
||||||
std::vector<const char*> compact_buckets; |
|
||||||
for (unsigned int bid = 0; bid < bucket_count_; ++bid) { |
|
||||||
const char* bucket = cuckoo_array_[bid].load(std::memory_order_relaxed); |
|
||||||
if (bucket != nullptr) { |
|
||||||
compact_buckets.push_back(bucket); |
|
||||||
} |
|
||||||
} |
|
||||||
MemTableRep* backup_table = backup_table_.get(); |
|
||||||
if (backup_table != nullptr) { |
|
||||||
std::unique_ptr<MemTableRep::Iterator> iter(backup_table->GetIterator()); |
|
||||||
for (iter->SeekToFirst(); iter->Valid(); iter->Next()) { |
|
||||||
compact_buckets.push_back(iter->key()); |
|
||||||
} |
|
||||||
} |
|
||||||
if (arena == nullptr) { |
|
||||||
return new Iterator( |
|
||||||
std::shared_ptr<std::vector<const char*>>( |
|
||||||
new std::vector<const char*>(std::move(compact_buckets))), |
|
||||||
compare_); |
|
||||||
} else { |
|
||||||
auto mem = arena->AllocateAligned(sizeof(Iterator)); |
|
||||||
return new (mem) Iterator( |
|
||||||
std::shared_ptr<std::vector<const char*>>( |
|
||||||
new std::vector<const char*>(std::move(compact_buckets))), |
|
||||||
compare_); |
|
||||||
} |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
void HashCuckooRep::Get(const LookupKey& key, void* callback_args, |
|
||||||
bool (*callback_func)(void* arg, const char* entry)) { |
|
||||||
Slice user_key = key.user_key(); |
|
||||||
for (unsigned int hid = 0; hid < hash_function_count_; ++hid) { |
|
||||||
const char* bucket = |
|
||||||
cuckoo_array_[GetHash(user_key, hid)].load(std::memory_order_acquire); |
|
||||||
if (bucket != nullptr) { |
|
||||||
Slice bucket_user_key = UserKey(bucket); |
|
||||||
if (user_key == bucket_user_key) { |
|
||||||
callback_func(callback_args, bucket); |
|
||||||
break; |
|
||||||
} |
|
||||||
} else { |
|
||||||
// as Put() always stores at the vacant bucket located by the
|
|
||||||
// hash function with the smallest possible id, when we first
|
|
||||||
// find a vacant bucket in Get(), that means a miss.
|
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
MemTableRep* backup_table = backup_table_.get(); |
|
||||||
if (backup_table != nullptr) { |
|
||||||
backup_table->Get(key, callback_args, callback_func); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void HashCuckooRep::Insert(KeyHandle handle) { |
|
||||||
static const float kMaxFullness = 0.90f; |
|
||||||
|
|
||||||
auto* key = static_cast<char*>(handle); |
|
||||||
int initial_hash_id = 0; |
|
||||||
size_t cuckoo_path_length = 0; |
|
||||||
auto user_key = UserKey(key); |
|
||||||
// find cuckoo path
|
|
||||||
if (FindCuckooPath(key, user_key, cuckoo_path_, &cuckoo_path_length, |
|
||||||
initial_hash_id) == false) { |
|
||||||
// if true, then we can't find a vacant bucket for this key even we
|
|
||||||
// have used up all the hash functions. Then use a backup memtable to
|
|
||||||
// store such key, which will further make this mem-table become
|
|
||||||
// immutable.
|
|
||||||
if (backup_table_.get() == nullptr) { |
|
||||||
VectorRepFactory factory(10); |
|
||||||
backup_table_.reset( |
|
||||||
factory.CreateMemTableRep(compare_, allocator_, nullptr, nullptr)); |
|
||||||
is_nearly_full_ = true; |
|
||||||
} |
|
||||||
backup_table_->Insert(key); |
|
||||||
return; |
|
||||||
} |
|
||||||
// when reaching this point, means the insert can be done successfully.
|
|
||||||
occupied_count_++; |
|
||||||
if (occupied_count_ >= bucket_count_ * kMaxFullness) { |
|
||||||
is_nearly_full_ = true; |
|
||||||
} |
|
||||||
|
|
||||||
// perform kickout process if the length of cuckoo path > 1.
|
|
||||||
if (cuckoo_path_length == 0) return; |
|
||||||
|
|
||||||
// the cuckoo path stores the kickout path in reverse order.
|
|
||||||
// so the kickout or displacement is actually performed
|
|
||||||
// in reverse order, which avoids false-negatives on read
|
|
||||||
// by moving each key involved in the cuckoo path to the new
|
|
||||||
// location before replacing it.
|
|
||||||
for (size_t i = 1; i < cuckoo_path_length; ++i) { |
|
||||||
int kicked_out_bid = cuckoo_path_[i - 1]; |
|
||||||
int current_bid = cuckoo_path_[i]; |
|
||||||
// since we only allow one writer at a time, it is safe to do relaxed read.
|
|
||||||
cuckoo_array_[kicked_out_bid] |
|
||||||
.store(cuckoo_array_[current_bid].load(std::memory_order_relaxed), |
|
||||||
std::memory_order_release); |
|
||||||
} |
|
||||||
int insert_key_bid = cuckoo_path_[cuckoo_path_length - 1]; |
|
||||||
cuckoo_array_[insert_key_bid].store(key, std::memory_order_release); |
|
||||||
} |
|
||||||
|
|
||||||
bool HashCuckooRep::Contains(const char* internal_key) const { |
|
||||||
auto user_key = UserKey(internal_key); |
|
||||||
for (unsigned int hid = 0; hid < hash_function_count_; ++hid) { |
|
||||||
const char* stored_key = |
|
||||||
cuckoo_array_[GetHash(user_key, hid)].load(std::memory_order_acquire); |
|
||||||
if (stored_key != nullptr) { |
|
||||||
if (compare_(internal_key, stored_key) == 0) { |
|
||||||
return true; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
bool HashCuckooRep::QuickInsert(const char* internal_key, const Slice& user_key, |
|
||||||
int bucket_ids[], const int initial_hash_id) { |
|
||||||
int cuckoo_bucket_id = -1; |
|
||||||
|
|
||||||
// Below does the followings:
|
|
||||||
// 0. Calculate all possible locations of the input key.
|
|
||||||
// 1. Check if there is a bucket having same user_key as the input does.
|
|
||||||
// 2. If there exists such bucket, then replace this bucket by the newly
|
|
||||||
// insert data and return. This step also performs duplication check.
|
|
||||||
// 3. If no such bucket exists but exists a vacant bucket, then insert the
|
|
||||||
// input data into it.
|
|
||||||
// 4. If step 1 to 3 all fail, then return false.
|
|
||||||
for (unsigned int hid = initial_hash_id; hid < hash_function_count_; ++hid) { |
|
||||||
bucket_ids[hid] = GetHash(user_key, hid); |
|
||||||
// since only one PUT is allowed at a time, and this is part of the PUT
|
|
||||||
// operation, so we can safely perform relaxed load.
|
|
||||||
const char* stored_key = |
|
||||||
cuckoo_array_[bucket_ids[hid]].load(std::memory_order_relaxed); |
|
||||||
if (stored_key == nullptr) { |
|
||||||
if (cuckoo_bucket_id == -1) { |
|
||||||
cuckoo_bucket_id = bucket_ids[hid]; |
|
||||||
} |
|
||||||
} else { |
|
||||||
const auto bucket_user_key = UserKey(stored_key); |
|
||||||
if (bucket_user_key.compare(user_key) == 0) { |
|
||||||
cuckoo_bucket_id = bucket_ids[hid]; |
|
||||||
assert(cuckoo_bucket_id != -1); |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if (cuckoo_bucket_id != -1) { |
|
||||||
cuckoo_array_[cuckoo_bucket_id].store(const_cast<char*>(internal_key), |
|
||||||
std::memory_order_release); |
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
// Perform pre-check and find the shortest cuckoo path. A cuckoo path
|
|
||||||
// is a displacement sequence for inserting the specified input key.
|
|
||||||
//
|
|
||||||
// @return true if it successfully found a vacant space or cuckoo-path.
|
|
||||||
// If the return value is true but the length of cuckoo_path is zero,
|
|
||||||
// then it indicates that a vacant bucket or an bucket with matched user
|
|
||||||
// key with the input is found, and a quick insertion is done.
|
|
||||||
bool HashCuckooRep::FindCuckooPath(const char* internal_key, |
|
||||||
const Slice& user_key, int* cuckoo_path, |
|
||||||
size_t* cuckoo_path_length, |
|
||||||
const int initial_hash_id) { |
|
||||||
int bucket_ids[HashCuckooRepFactory::kMaxHashCount]; |
|
||||||
*cuckoo_path_length = 0; |
|
||||||
|
|
||||||
if (QuickInsert(internal_key, user_key, bucket_ids, initial_hash_id)) { |
|
||||||
return true; |
|
||||||
} |
|
||||||
// If this step is reached, then it means:
|
|
||||||
// 1. no vacant bucket in any of the possible locations of the input key.
|
|
||||||
// 2. none of the possible locations of the input key has the same user
|
|
||||||
// key as the input `internal_key`.
|
|
||||||
|
|
||||||
// the front and back indices for the step_queue_
|
|
||||||
step_buffer_.reset(); |
|
||||||
|
|
||||||
for (unsigned int hid = initial_hash_id; hid < hash_function_count_; ++hid) { |
|
||||||
/// CuckooStep& current_step = step_queue_[front_pos++];
|
|
||||||
CuckooStep& current_step = step_buffer_.NextWriteBuffer(); |
|
||||||
current_step.bucket_id_ = bucket_ids[hid]; |
|
||||||
current_step.prev_step_id_ = CuckooStep::kNullStep; |
|
||||||
current_step.depth_ = 1; |
|
||||||
} |
|
||||||
|
|
||||||
while (step_buffer_.HasNewWrite()) { |
|
||||||
int step_id = step_buffer_.read_index_; |
|
||||||
const CuckooStep& step = step_buffer_.ReadNext(); |
|
||||||
// Since it's a BFS process, then the first step with its depth deeper
|
|
||||||
// than the maximum allowed depth indicates all the remaining steps
|
|
||||||
// in the step buffer queue will all exceed the maximum depth.
|
|
||||||
// Return false immediately indicating we can't find a vacant bucket
|
|
||||||
// for the input key before the maximum allowed depth.
|
|
||||||
if (step.depth_ >= cuckoo_path_max_depth_) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
// again, we can perform no barrier load safely here as the current
|
|
||||||
// thread is the only writer.
|
|
||||||
Slice bucket_user_key = |
|
||||||
UserKey(cuckoo_array_[step.bucket_id_].load(std::memory_order_relaxed)); |
|
||||||
if (step.prev_step_id_ != CuckooStep::kNullStep) { |
|
||||||
if (bucket_user_key == user_key) { |
|
||||||
// then there is a loop in the current path, stop discovering this path.
|
|
||||||
continue; |
|
||||||
} |
|
||||||
} |
|
||||||
// if the current bucket stores at its nth location, then we only consider
|
|
||||||
// its mth location where m > n. This property makes sure that all reads
|
|
||||||
// will not miss if we do have data associated to the query key.
|
|
||||||
//
|
|
||||||
// The n and m in the above statement is the start_hid and hid in the code.
|
|
||||||
unsigned int start_hid = hash_function_count_; |
|
||||||
for (unsigned int hid = 0; hid < hash_function_count_; ++hid) { |
|
||||||
bucket_ids[hid] = GetHash(bucket_user_key, hid); |
|
||||||
if (step.bucket_id_ == bucket_ids[hid]) { |
|
||||||
start_hid = hid; |
|
||||||
} |
|
||||||
} |
|
||||||
// must found a bucket which is its current "home".
|
|
||||||
assert(start_hid != hash_function_count_); |
|
||||||
|
|
||||||
// explore all possible next steps from the current step.
|
|
||||||
for (unsigned int hid = start_hid + 1; hid < hash_function_count_; ++hid) { |
|
||||||
CuckooStep& next_step = step_buffer_.NextWriteBuffer(); |
|
||||||
next_step.bucket_id_ = bucket_ids[hid]; |
|
||||||
next_step.prev_step_id_ = step_id; |
|
||||||
next_step.depth_ = step.depth_ + 1; |
|
||||||
// once a vacant bucket is found, trace back all its previous steps
|
|
||||||
// to generate a cuckoo path.
|
|
||||||
if (cuckoo_array_[next_step.bucket_id_].load(std::memory_order_relaxed) == |
|
||||||
nullptr) { |
|
||||||
// store the last step in the cuckoo path. Note that cuckoo_path
|
|
||||||
// stores steps in reverse order. This allows us to move keys along
|
|
||||||
// the cuckoo path by storing each key to the new place first before
|
|
||||||
// removing it from the old place. This property ensures reads will
|
|
||||||
// not missed due to moving keys along the cuckoo path.
|
|
||||||
cuckoo_path[(*cuckoo_path_length)++] = next_step.bucket_id_; |
|
||||||
int depth; |
|
||||||
for (depth = step.depth_; depth > 0 && step_id != CuckooStep::kNullStep; |
|
||||||
depth--) { |
|
||||||
const CuckooStep& prev_step = step_buffer_.steps_[step_id]; |
|
||||||
cuckoo_path[(*cuckoo_path_length)++] = prev_step.bucket_id_; |
|
||||||
step_id = prev_step.prev_step_id_; |
|
||||||
} |
|
||||||
assert(depth == 0 && step_id == CuckooStep::kNullStep); |
|
||||||
return true; |
|
||||||
} |
|
||||||
if (step_buffer_.IsFull()) { |
|
||||||
// if true, then it reaches maxinum number of cuckoo search steps.
|
|
||||||
return false; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// tried all possible paths but still not unable to find a cuckoo path
|
|
||||||
// which path leads to a vacant bucket.
|
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
HashCuckooRep::Iterator::Iterator( |
|
||||||
std::shared_ptr<std::vector<const char*>> bucket, |
|
||||||
const KeyComparator& compare) |
|
||||||
: bucket_(bucket), |
|
||||||
cit_(bucket_->end()), |
|
||||||
compare_(compare), |
|
||||||
sorted_(false) {} |
|
||||||
|
|
||||||
void HashCuckooRep::Iterator::DoSort() const { |
|
||||||
if (!sorted_) { |
|
||||||
std::sort(bucket_->begin(), bucket_->end(), |
|
||||||
stl_wrappers::Compare(compare_)); |
|
||||||
cit_ = bucket_->begin(); |
|
||||||
sorted_ = true; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Returns true iff the iterator is positioned at a valid node.
|
|
||||||
bool HashCuckooRep::Iterator::Valid() const { |
|
||||||
DoSort(); |
|
||||||
return cit_ != bucket_->end(); |
|
||||||
} |
|
||||||
|
|
||||||
// Returns the key at the current position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
const char* HashCuckooRep::Iterator::key() const { |
|
||||||
assert(Valid()); |
|
||||||
return *cit_; |
|
||||||
} |
|
||||||
|
|
||||||
// Advances to the next position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
void HashCuckooRep::Iterator::Next() { |
|
||||||
assert(Valid()); |
|
||||||
if (cit_ == bucket_->end()) { |
|
||||||
return; |
|
||||||
} |
|
||||||
++cit_; |
|
||||||
} |
|
||||||
|
|
||||||
// Advances to the previous position.
|
|
||||||
// REQUIRES: Valid()
|
|
||||||
void HashCuckooRep::Iterator::Prev() { |
|
||||||
assert(Valid()); |
|
||||||
if (cit_ == bucket_->begin()) { |
|
||||||
// If you try to go back from the first element, the iterator should be
|
|
||||||
// invalidated. So we set it to past-the-end. This means that you can
|
|
||||||
// treat the container circularly.
|
|
||||||
cit_ = bucket_->end(); |
|
||||||
} else { |
|
||||||
--cit_; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Advance to the first entry with a key >= target
|
|
||||||
void HashCuckooRep::Iterator::Seek(const Slice& user_key, |
|
||||||
const char* memtable_key) { |
|
||||||
DoSort(); |
|
||||||
// Do binary search to find first value not less than the target
|
|
||||||
const char* encoded_key = |
|
||||||
(memtable_key != nullptr) ? memtable_key : EncodeKey(&tmp_, user_key); |
|
||||||
cit_ = std::equal_range(bucket_->begin(), bucket_->end(), encoded_key, |
|
||||||
[this](const char* a, const char* b) { |
|
||||||
return compare_(a, b) < 0; |
|
||||||
}).first; |
|
||||||
} |
|
||||||
|
|
||||||
// Retreat to the last entry with a key <= target
|
|
||||||
void HashCuckooRep::Iterator::SeekForPrev(const Slice& /*user_key*/, |
|
||||||
const char* /*memtable_key*/) { |
|
||||||
assert(false); |
|
||||||
} |
|
||||||
|
|
||||||
// Position at the first entry in collection.
|
|
||||||
// Final state of iterator is Valid() iff collection is not empty.
|
|
||||||
void HashCuckooRep::Iterator::SeekToFirst() { |
|
||||||
DoSort(); |
|
||||||
cit_ = bucket_->begin(); |
|
||||||
} |
|
||||||
|
|
||||||
// Position at the last entry in collection.
|
|
||||||
// Final state of iterator is Valid() iff collection is not empty.
|
|
||||||
void HashCuckooRep::Iterator::SeekToLast() { |
|
||||||
DoSort(); |
|
||||||
cit_ = bucket_->end(); |
|
||||||
if (bucket_->size() != 0) { |
|
||||||
--cit_; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
} // anom namespace
|
|
||||||
|
|
||||||
MemTableRep* HashCuckooRepFactory::CreateMemTableRep( |
|
||||||
const MemTableRep::KeyComparator& compare, Allocator* allocator, |
|
||||||
const SliceTransform* /*transform*/, Logger* /*logger*/) { |
|
||||||
// The estimated average fullness. The write performance of any close hash
|
|
||||||
// degrades as the fullness of the mem-table increases. Setting kFullness
|
|
||||||
// to a value around 0.7 can better avoid write performance degradation while
|
|
||||||
// keeping efficient memory usage.
|
|
||||||
static const float kFullness = 0.7f; |
|
||||||
size_t pointer_size = sizeof(std::atomic<const char*>); |
|
||||||
assert(write_buffer_size_ >= (average_data_size_ + pointer_size)); |
|
||||||
size_t bucket_count = |
|
||||||
static_cast<size_t>( |
|
||||||
(write_buffer_size_ / (average_data_size_ + pointer_size)) / kFullness + |
|
||||||
1); |
|
||||||
unsigned int hash_function_count = hash_function_count_; |
|
||||||
if (hash_function_count < 2) { |
|
||||||
hash_function_count = 2; |
|
||||||
} |
|
||||||
if (hash_function_count > kMaxHashCount) { |
|
||||||
hash_function_count = kMaxHashCount; |
|
||||||
} |
|
||||||
return new HashCuckooRep(compare, allocator, bucket_count, |
|
||||||
hash_function_count, |
|
||||||
static_cast<size_t>( |
|
||||||
(average_data_size_ + pointer_size) / kFullness) |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
MemTableRepFactory* NewHashCuckooRepFactory(size_t write_buffer_size, |
|
||||||
size_t average_data_size, |
|
||||||
unsigned int hash_function_count) { |
|
||||||
return new HashCuckooRepFactory(write_buffer_size, average_data_size, |
|
||||||
hash_function_count); |
|
||||||
} |
|
||||||
|
|
||||||
} // namespace rocksdb
|
|
||||||
#endif // ROCKSDB_LITE
|
|
||||||
@ -1,44 +0,0 @@ |
|||||||
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
||||||
// This source code is licensed under both the GPLv2 (found in the
|
|
||||||
// COPYING file in the root directory) and Apache 2.0 License
|
|
||||||
// (found in the LICENSE.Apache file in the root 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.
|
|
||||||
|
|
||||||
#pragma once |
|
||||||
#ifndef ROCKSDB_LITE |
|
||||||
#include "port/port.h" |
|
||||||
#include "rocksdb/slice_transform.h" |
|
||||||
#include "rocksdb/memtablerep.h" |
|
||||||
|
|
||||||
namespace rocksdb { |
|
||||||
|
|
||||||
class HashCuckooRepFactory : public MemTableRepFactory { |
|
||||||
public: |
|
||||||
// maxinum number of hash functions used in the cuckoo hash.
|
|
||||||
static const unsigned int kMaxHashCount = 10; |
|
||||||
|
|
||||||
explicit HashCuckooRepFactory(size_t write_buffer_size, |
|
||||||
size_t average_data_size, |
|
||||||
unsigned int hash_function_count) |
|
||||||
: write_buffer_size_(write_buffer_size), |
|
||||||
average_data_size_(average_data_size), |
|
||||||
hash_function_count_(hash_function_count) {} |
|
||||||
|
|
||||||
virtual ~HashCuckooRepFactory() {} |
|
||||||
|
|
||||||
using MemTableRepFactory::CreateMemTableRep; |
|
||||||
virtual MemTableRep* CreateMemTableRep( |
|
||||||
const MemTableRep::KeyComparator& compare, Allocator* allocator, |
|
||||||
const SliceTransform* transform, Logger* logger) override; |
|
||||||
|
|
||||||
virtual const char* Name() const override { return "HashCuckooRepFactory"; } |
|
||||||
|
|
||||||
private: |
|
||||||
size_t write_buffer_size_; |
|
||||||
size_t average_data_size_; |
|
||||||
const unsigned int hash_function_count_; |
|
||||||
}; |
|
||||||
} // namespace rocksdb
|
|
||||||
#endif // ROCKSDB_LITE
|
|
||||||
Loading…
Reference in new issue