Summary: Adding option to save PlainTable index and bloom filter in SST file. If there is no bloom block and/or index block, PlainTableReader builds new ones. Otherwise PlainTableReader just use these blocks. Test Plan: make all check Reviewers: sdong Reviewed By: sdong Subscribers: leveldb Differential Revision: https://reviews.facebook.net/D19527main
Stanislau Hlebik
10 years ago
parent
92d73cbe78
commit
9d70cce047
@ -0,0 +1,23 @@ |
||||
// Copyright (c) 2014, 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.
|
||||
|
||||
#include "table/bloom_block.h" |
||||
|
||||
#include <string> |
||||
#include "rocksdb/slice.h" |
||||
#include "util/dynamic_bloom.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
void BloomBlockBuilder::AddKeysHashes(const std::vector<uint32_t> keys_hashes) { |
||||
for (auto hash : keys_hashes) { |
||||
bloom_.AddHash(hash); |
||||
} |
||||
} |
||||
|
||||
Slice BloomBlockBuilder::Finish() { return bloom_.GetRawData(); } |
||||
|
||||
const std::string BloomBlockBuilder::kBloomBlock = "kBloomBlock"; |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,37 @@ |
||||
// Copyright (c) 2014, 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.
|
||||
#pragma once |
||||
|
||||
#include <vector> |
||||
#include <string> |
||||
#include "util/dynamic_bloom.h" |
||||
|
||||
namespace rocksdb { |
||||
class Logger; |
||||
|
||||
class BloomBlockBuilder { |
||||
public: |
||||
static const std::string kBloomBlock; |
||||
|
||||
explicit BloomBlockBuilder(uint32_t num_probes = 6) |
||||
: bloom_(num_probes, nullptr) {} |
||||
|
||||
void SetTotalBits(Arena* arena, uint32_t total_bits, uint32_t locality, |
||||
size_t huge_page_tlb_size, Logger* logger) { |
||||
bloom_.SetTotalBits(arena, total_bits, locality, huge_page_tlb_size, |
||||
logger); |
||||
} |
||||
|
||||
uint32_t GetNumBlocks() const { return bloom_.GetNumBlocks(); } |
||||
|
||||
void AddKeysHashes(const std::vector<uint32_t> keys_hashes); |
||||
|
||||
Slice Finish(); |
||||
|
||||
private: |
||||
DynamicBloom bloom_; |
||||
}; |
||||
|
||||
}; // namespace rocksdb
|
||||
@ -0,0 +1,196 @@ |
||||
// Copyright (c) 2014, 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.
|
||||
|
||||
#include "table/plain_table_index.h" |
||||
#include "util/coding.h" |
||||
#include "util/hash.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
namespace { |
||||
inline uint32_t GetBucketIdFromHash(uint32_t hash, uint32_t num_buckets) { |
||||
assert(num_buckets > 0); |
||||
return hash % num_buckets; |
||||
} |
||||
} |
||||
|
||||
void PlainTableIndex::InitFromRawData(Slice data) { |
||||
assert(GetVarint32(&data, &index_size_)); |
||||
assert(index_size_ > 0); |
||||
assert(GetVarint32(&data, &num_prefixes_)); |
||||
sub_index_size_ = data.size() - index_size_ * kOffsetLen; |
||||
|
||||
char* index_data_begin = const_cast<char*>(data.data()); |
||||
index_ = reinterpret_cast<uint32_t*>(index_data_begin); |
||||
sub_index_ = reinterpret_cast<char*>(index_ + index_size_); |
||||
} |
||||
|
||||
PlainTableIndex::IndexSearchResult PlainTableIndex::GetOffset( |
||||
uint32_t prefix_hash, uint32_t* bucket_value) const { |
||||
int bucket = GetBucketIdFromHash(prefix_hash, index_size_); |
||||
*bucket_value = index_[bucket]; |
||||
if ((*bucket_value & kSubIndexMask) == kSubIndexMask) { |
||||
*bucket_value ^= kSubIndexMask; |
||||
return kSubindex; |
||||
} |
||||
if (*bucket_value >= kMaxFileSize) { |
||||
return kNoPrefixForBucket; |
||||
} else { |
||||
// point directly to the file
|
||||
return kDirectToFile; |
||||
} |
||||
} |
||||
|
||||
void PlainTableIndexBuilder::IndexRecordList::AddRecord(murmur_t hash, |
||||
uint32_t offset) { |
||||
if (num_records_in_current_group_ == kNumRecordsPerGroup) { |
||||
current_group_ = AllocateNewGroup(); |
||||
num_records_in_current_group_ = 0; |
||||
} |
||||
auto& new_record = current_group_[num_records_in_current_group_++]; |
||||
new_record.hash = hash; |
||||
new_record.offset = offset; |
||||
new_record.next = nullptr; |
||||
} |
||||
|
||||
void PlainTableIndexBuilder::AddKeyPrefix(Slice key_prefix_slice, |
||||
uint64_t key_offset) { |
||||
if (is_first_record_ || prev_key_prefix_ != key_prefix_slice.ToString()) { |
||||
++num_prefixes_; |
||||
if (!is_first_record_) { |
||||
keys_per_prefix_hist_.Add(num_keys_per_prefix_); |
||||
} |
||||
num_keys_per_prefix_ = 0; |
||||
prev_key_prefix_ = key_prefix_slice.ToString(); |
||||
prev_key_prefix_hash_ = GetSliceHash(key_prefix_slice); |
||||
due_index_ = true; |
||||
} |
||||
|
||||
if (due_index_) { |
||||
// Add an index key for every kIndexIntervalForSamePrefixKeys keys
|
||||
record_list_.AddRecord(prev_key_prefix_hash_, key_offset); |
||||
due_index_ = false; |
||||
} |
||||
|
||||
num_keys_per_prefix_++; |
||||
if (index_sparseness_ == 0 || num_keys_per_prefix_ % index_sparseness_ == 0) { |
||||
due_index_ = true; |
||||
} |
||||
is_first_record_ = false; |
||||
} |
||||
|
||||
Slice PlainTableIndexBuilder::Finish() { |
||||
AllocateIndex(); |
||||
std::vector<IndexRecord*> hash_to_offsets(index_size_, nullptr); |
||||
std::vector<uint32_t> entries_per_bucket(index_size_, 0); |
||||
BucketizeIndexes(&hash_to_offsets, &entries_per_bucket); |
||||
|
||||
keys_per_prefix_hist_.Add(num_keys_per_prefix_); |
||||
Log(options_.info_log, "Number of Keys per prefix Histogram: %s", |
||||
keys_per_prefix_hist_.ToString().c_str()); |
||||
|
||||
// From the temp data structure, populate indexes.
|
||||
return FillIndexes(hash_to_offsets, entries_per_bucket); |
||||
} |
||||
|
||||
void PlainTableIndexBuilder::AllocateIndex() { |
||||
if (prefix_extractor_ == nullptr || hash_table_ratio_ <= 0) { |
||||
// Fall back to pure binary search if the user fails to specify a prefix
|
||||
// extractor.
|
||||
index_size_ = 1; |
||||
} else { |
||||
double hash_table_size_multipier = 1.0 / hash_table_ratio_; |
||||
index_size_ = num_prefixes_ * hash_table_size_multipier + 1; |
||||
assert(index_size_ > 0); |
||||
} |
||||
} |
||||
|
||||
void PlainTableIndexBuilder::BucketizeIndexes( |
||||
std::vector<IndexRecord*>* hash_to_offsets, |
||||
std::vector<uint32_t>* entries_per_bucket) { |
||||
bool first = true; |
||||
uint32_t prev_hash = 0; |
||||
size_t num_records = record_list_.GetNumRecords(); |
||||
for (size_t i = 0; i < num_records; i++) { |
||||
IndexRecord* index_record = record_list_.At(i); |
||||
uint32_t cur_hash = index_record->hash; |
||||
if (first || prev_hash != cur_hash) { |
||||
prev_hash = cur_hash; |
||||
first = false; |
||||
} |
||||
uint32_t bucket = GetBucketIdFromHash(cur_hash, index_size_); |
||||
IndexRecord* prev_bucket_head = (*hash_to_offsets)[bucket]; |
||||
index_record->next = prev_bucket_head; |
||||
(*hash_to_offsets)[bucket] = index_record; |
||||
(*entries_per_bucket)[bucket]++; |
||||
} |
||||
|
||||
sub_index_size_ = 0; |
||||
for (auto entry_count : *entries_per_bucket) { |
||||
if (entry_count <= 1) { |
||||
continue; |
||||
} |
||||
// Only buckets with more than 1 entry will have subindex.
|
||||
sub_index_size_ += VarintLength(entry_count); |
||||
// total bytes needed to store these entries' in-file offsets.
|
||||
sub_index_size_ += entry_count * PlainTableIndex::kOffsetLen; |
||||
} |
||||
} |
||||
|
||||
Slice PlainTableIndexBuilder::FillIndexes( |
||||
const std::vector<IndexRecord*>& hash_to_offsets, |
||||
const std::vector<uint32_t>& entries_per_bucket) { |
||||
Log(options_.info_log, "Reserving %zu bytes for plain table's sub_index", |
||||
sub_index_size_); |
||||
auto total_allocate_size = GetTotalSize(); |
||||
char* allocated = arena_->AllocateAligned( |
||||
total_allocate_size, huge_page_tlb_size_, options_.info_log.get()); |
||||
|
||||
auto temp_ptr = EncodeVarint32(allocated, index_size_); |
||||
uint32_t* index = |
||||
reinterpret_cast<uint32_t*>(EncodeVarint32(temp_ptr, num_prefixes_)); |
||||
char* sub_index = reinterpret_cast<char*>(index + index_size_); |
||||
|
||||
size_t sub_index_offset = 0; |
||||
for (uint32_t i = 0; i < index_size_; i++) { |
||||
uint32_t num_keys_for_bucket = entries_per_bucket[i]; |
||||
switch (num_keys_for_bucket) { |
||||
case 0: |
||||
// No key for bucket
|
||||
index[i] = PlainTableIndex::kMaxFileSize; |
||||
break; |
||||
case 1: |
||||
// point directly to the file offset
|
||||
index[i] = hash_to_offsets[i]->offset; |
||||
break; |
||||
default: |
||||
// point to second level indexes.
|
||||
index[i] = sub_index_offset | PlainTableIndex::kSubIndexMask; |
||||
char* prev_ptr = &sub_index[sub_index_offset]; |
||||
char* cur_ptr = EncodeVarint32(prev_ptr, num_keys_for_bucket); |
||||
sub_index_offset += (cur_ptr - prev_ptr); |
||||
char* sub_index_pos = &sub_index[sub_index_offset]; |
||||
IndexRecord* record = hash_to_offsets[i]; |
||||
int j; |
||||
for (j = num_keys_for_bucket - 1; j >= 0 && record; |
||||
j--, record = record->next) { |
||||
EncodeFixed32(sub_index_pos + j * sizeof(uint32_t), record->offset); |
||||
} |
||||
assert(j == -1 && record == nullptr); |
||||
sub_index_offset += PlainTableIndex::kOffsetLen * num_keys_for_bucket; |
||||
assert(sub_index_offset <= sub_index_size_); |
||||
break; |
||||
} |
||||
} |
||||
assert(sub_index_offset == sub_index_size_); |
||||
|
||||
Log(options_.info_log, "hash table size: %d, suffix_map length %zu", |
||||
index_size_, sub_index_size_); |
||||
return Slice(allocated, GetTotalSize()); |
||||
} |
||||
|
||||
const std::string PlainTableIndexBuilder::kPlainTableIndexBlock = |
||||
"PlainTableIndexBlock"; |
||||
}; // namespace rocksdb
|
||||
@ -0,0 +1,221 @@ |
||||
// Copyright (c) 2014, 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.
|
||||
|
||||
#pragma once |
||||
|
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
#include "db/dbformat.h" |
||||
#include "rocksdb/options.h" |
||||
#include "util/murmurhash.h" |
||||
#include "util/hash.h" |
||||
#include "util/arena.h" |
||||
#include "util/histogram.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
// PlainTableIndex contains buckets size of index_size_, each is a
|
||||
// 32-bit integer. The lower 31 bits contain an offset value (explained below)
|
||||
// and the first bit of the integer indicates type of the offset.
|
||||
//
|
||||
// +--------------+------------------------------------------------------+
|
||||
// | Flag (1 bit) | Offset to binary search buffer or file (31 bits) +
|
||||
// +--------------+------------------------------------------------------+
|
||||
//
|
||||
// Explanation for the "flag bit":
|
||||
//
|
||||
// 0 indicates that the bucket contains only one prefix (no conflict when
|
||||
// hashing this prefix), whose first row starts from this offset of the
|
||||
// file.
|
||||
// 1 indicates that the bucket contains more than one prefixes, or there
|
||||
// are too many rows for one prefix so we need a binary search for it. In
|
||||
// this case, the offset indicates the offset of sub_index_ holding the
|
||||
// binary search indexes of keys for those rows. Those binary search indexes
|
||||
// are organized in this way:
|
||||
//
|
||||
// The first 4 bytes, indicate how many indexes (N) are stored after it. After
|
||||
// it, there are N 32-bit integers, each points of an offset of the file,
|
||||
// which
|
||||
// points to starting of a row. Those offsets need to be guaranteed to be in
|
||||
// ascending order so the keys they are pointing to are also in ascending
|
||||
// order
|
||||
// to make sure we can use them to do binary searches. Below is visual
|
||||
// presentation of a bucket.
|
||||
//
|
||||
// <begin>
|
||||
// number_of_records: varint32
|
||||
// record 1 file offset: fixedint32
|
||||
// record 2 file offset: fixedint32
|
||||
// ....
|
||||
// record N file offset: fixedint32
|
||||
// <end>
|
||||
class PlainTableIndex { |
||||
public: |
||||
enum IndexSearchResult { |
||||
kNoPrefixForBucket = 0, |
||||
kDirectToFile = 1, |
||||
kSubindex = 2 |
||||
}; |
||||
|
||||
explicit PlainTableIndex(Slice data) { InitFromRawData(data); } |
||||
|
||||
PlainTableIndex() |
||||
: index_size_(0), |
||||
sub_index_size_(0), |
||||
num_prefixes_(0), |
||||
index_(nullptr), |
||||
sub_index_(nullptr) {} |
||||
|
||||
IndexSearchResult GetOffset(uint32_t prefix_hash, |
||||
uint32_t* bucket_value) const; |
||||
|
||||
void InitFromRawData(Slice data); |
||||
|
||||
const char* GetSubIndexBasePtrAndUpperBound(uint32_t offset, |
||||
uint32_t* upper_bound) const { |
||||
const char* index_ptr = &sub_index_[offset]; |
||||
return GetVarint32Ptr(index_ptr, index_ptr + 4, upper_bound); |
||||
} |
||||
|
||||
uint32_t GetIndexSize() const { return index_size_; } |
||||
|
||||
uint32_t GetSubIndexSize() const { return sub_index_size_; } |
||||
|
||||
uint32_t GetNumPrefixes() const { return num_prefixes_; } |
||||
|
||||
static const uint64_t kMaxFileSize = (1u << 31) - 1; |
||||
static const uint32_t kSubIndexMask = 0x80000000; |
||||
static const size_t kOffsetLen = sizeof(uint32_t); |
||||
|
||||
private: |
||||
uint32_t index_size_; |
||||
size_t sub_index_size_; |
||||
uint32_t num_prefixes_; |
||||
|
||||
uint32_t* index_; |
||||
char* sub_index_; |
||||
}; |
||||
|
||||
// PlainTableIndexBuilder is used to create plain table index.
|
||||
// After calling Finish(), it returns Slice, which is usually
|
||||
// used either to initialize PlainTableIndex or
|
||||
// to save index to sst file.
|
||||
// For more details about the index, please refer to:
|
||||
// https://github.com/facebook/rocksdb/wiki/PlainTable-Format
|
||||
// #wiki-in-memory-index-format
|
||||
class PlainTableIndexBuilder { |
||||
public: |
||||
PlainTableIndexBuilder(Arena* arena, const Options& options, |
||||
uint32_t index_sparseness, double hash_table_ratio, |
||||
double huge_page_tlb_size) |
||||
: arena_(arena), |
||||
options_(options), |
||||
record_list_(kRecordsPerGroup), |
||||
is_first_record_(true), |
||||
due_index_(false), |
||||
num_prefixes_(0), |
||||
num_keys_per_prefix_(0), |
||||
prev_key_prefix_hash_(0), |
||||
index_sparseness_(index_sparseness), |
||||
prefix_extractor_(options.prefix_extractor.get()), |
||||
hash_table_ratio_(hash_table_ratio), |
||||
huge_page_tlb_size_(huge_page_tlb_size) {} |
||||
|
||||
void AddKeyPrefix(Slice key_prefix_slice, uint64_t key_offset); |
||||
|
||||
Slice Finish(); |
||||
|
||||
uint32_t GetTotalSize() const { |
||||
return VarintLength(index_size_) + VarintLength(num_prefixes_) + |
||||
PlainTableIndex::kOffsetLen * index_size_ + sub_index_size_; |
||||
} |
||||
|
||||
static const std::string kPlainTableIndexBlock; |
||||
|
||||
private: |
||||
struct IndexRecord { |
||||
uint32_t hash; // hash of the prefix
|
||||
uint32_t offset; // offset of a row
|
||||
IndexRecord* next; |
||||
}; |
||||
|
||||
// Helper class to track all the index records
|
||||
class IndexRecordList { |
||||
public: |
||||
explicit IndexRecordList(size_t num_records_per_group) |
||||
: kNumRecordsPerGroup(num_records_per_group), |
||||
current_group_(nullptr), |
||||
num_records_in_current_group_(num_records_per_group) {} |
||||
|
||||
~IndexRecordList() { |
||||
for (size_t i = 0; i < groups_.size(); i++) { |
||||
delete[] groups_[i]; |
||||
} |
||||
} |
||||
|
||||
void AddRecord(murmur_t hash, uint32_t offset); |
||||
|
||||
size_t GetNumRecords() const { |
||||
return (groups_.size() - 1) * kNumRecordsPerGroup + |
||||
num_records_in_current_group_; |
||||
} |
||||
IndexRecord* At(size_t index) { |
||||
return &(groups_[index / kNumRecordsPerGroup] |
||||
[index % kNumRecordsPerGroup]); |
||||
} |
||||
|
||||
private: |
||||
IndexRecord* AllocateNewGroup() { |
||||
IndexRecord* result = new IndexRecord[kNumRecordsPerGroup]; |
||||
groups_.push_back(result); |
||||
return result; |
||||
} |
||||
|
||||
// Each group in `groups_` contains fix-sized records (determined by
|
||||
// kNumRecordsPerGroup). Which can help us minimize the cost if resizing
|
||||
// occurs.
|
||||
const size_t kNumRecordsPerGroup; |
||||
IndexRecord* current_group_; |
||||
// List of arrays allocated
|
||||
std::vector<IndexRecord*> groups_; |
||||
size_t num_records_in_current_group_; |
||||
}; |
||||
|
||||
void AllocateIndex(); |
||||
|
||||
// Internal helper function to bucket index record list to hash buckets.
|
||||
void BucketizeIndexes(std::vector<IndexRecord*>* hash_to_offsets, |
||||
std::vector<uint32_t>* entries_per_bucket); |
||||
|
||||
// Internal helper class to fill the indexes and bloom filters to internal
|
||||
// data structures.
|
||||
Slice FillIndexes(const std::vector<IndexRecord*>& hash_to_offsets, |
||||
const std::vector<uint32_t>& entries_per_bucket); |
||||
|
||||
Arena* arena_; |
||||
Options options_; |
||||
HistogramImpl keys_per_prefix_hist_; |
||||
IndexRecordList record_list_; |
||||
bool is_first_record_; |
||||
bool due_index_; |
||||
uint32_t num_prefixes_; |
||||
uint32_t num_keys_per_prefix_; |
||||
|
||||
uint32_t prev_key_prefix_hash_; |
||||
uint32_t index_sparseness_; |
||||
uint32_t index_size_; |
||||
size_t sub_index_size_; |
||||
|
||||
const SliceTransform* prefix_extractor_; |
||||
double hash_table_ratio_; |
||||
double huge_page_tlb_size_; |
||||
|
||||
std::string prev_key_prefix_; |
||||
|
||||
static const size_t kRecordsPerGroup = 256; |
||||
}; |
||||
|
||||
}; // namespace rocksdb
|
||||
Loading…
Reference in new issue