80f409ea37
Summary: Clean PlainTableReader's data structures: (1) inline bloom_ (in order to do this, change DynamicBloom to allow lazy initialization) (2) remove some variables only used when initialization from the class (3) put variables not used in normal read code paths to the end of the class and reference prefix_extractor directly (4) make Options a reference. Test Plan: make all check Reviewers: haobo, ljin Reviewed By: ljin Subscribers: igor, yhchiang, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D18891
132 lines
4.3 KiB
C++
132 lines
4.3 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.
|
|
|
|
#pragma once
|
|
|
|
#include <atomic>
|
|
#include <memory>
|
|
|
|
#include "port/port.h"
|
|
#include <util/arena.h>
|
|
|
|
namespace rocksdb {
|
|
|
|
class Slice;
|
|
class Logger;
|
|
|
|
class DynamicBloom {
|
|
public:
|
|
// total_bits: fixed total bits for the bloom
|
|
// num_probes: number of hash probes for a single key
|
|
// locality: If positive, optimize for cache line locality, 0 otherwise.
|
|
// hash_func: customized hash function
|
|
// huge_page_tlb_size: if >0, try to allocate bloom bytes from huge page TLB
|
|
// withi this page size. Need to reserve huge pages for
|
|
// it to be allocated, like:
|
|
// sysctl -w vm.nr_hugepages=20
|
|
// See linux doc Documentation/vm/hugetlbpage.txt
|
|
explicit DynamicBloom(uint32_t total_bits, uint32_t locality = 0,
|
|
uint32_t num_probes = 6,
|
|
uint32_t (*hash_func)(const Slice& key) = nullptr,
|
|
size_t huge_page_tlb_size = 0,
|
|
Logger* logger = nullptr);
|
|
|
|
explicit DynamicBloom(uint32_t num_probes = 6,
|
|
uint32_t (*hash_func)(const Slice& key) = nullptr);
|
|
|
|
void SetTotalBits(uint32_t total_bits, uint32_t locality,
|
|
size_t huge_page_tlb_size, Logger* logger);
|
|
|
|
~DynamicBloom() {}
|
|
|
|
// Assuming single threaded access to this function.
|
|
void Add(const Slice& key);
|
|
|
|
// Assuming single threaded access to this function.
|
|
void AddHash(uint32_t hash);
|
|
|
|
// Multithreaded access to this function is OK
|
|
bool MayContain(const Slice& key) const;
|
|
|
|
// Multithreaded access to this function is OK
|
|
bool MayContainHash(uint32_t hash) const;
|
|
|
|
private:
|
|
uint32_t kTotalBits;
|
|
uint32_t kNumBlocks;
|
|
const uint32_t kNumProbes;
|
|
|
|
uint32_t (*hash_func_)(const Slice& key);
|
|
unsigned char* data_;
|
|
unsigned char* raw_;
|
|
|
|
Arena arena_;
|
|
};
|
|
|
|
inline void DynamicBloom::Add(const Slice& key) { AddHash(hash_func_(key)); }
|
|
|
|
inline bool DynamicBloom::MayContain(const Slice& key) const {
|
|
return (MayContainHash(hash_func_(key)));
|
|
}
|
|
|
|
inline bool DynamicBloom::MayContainHash(uint32_t h) const {
|
|
assert(kNumBlocks > 0 || kTotalBits > 0);
|
|
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
|
|
if (kNumBlocks != 0) {
|
|
uint32_t b = ((h >> 11 | (h << 21)) % kNumBlocks) * (CACHE_LINE_SIZE * 8);
|
|
for (uint32_t i = 0; i < kNumProbes; ++i) {
|
|
// Since CACHE_LINE_SIZE is defined as 2^n, this line will be optimized
|
|
// to a simple and operation by compiler.
|
|
const uint32_t bitpos = b + (h % (CACHE_LINE_SIZE * 8));
|
|
if (((data_[bitpos / 8]) & (1 << (bitpos % 8))) == 0) {
|
|
return false;
|
|
}
|
|
// Rotate h so that we don't reuse the same bytes.
|
|
h = h / (CACHE_LINE_SIZE * 8) +
|
|
(h % (CACHE_LINE_SIZE * 8)) * (0x20000000U / CACHE_LINE_SIZE);
|
|
h += delta;
|
|
}
|
|
} else {
|
|
if (kTotalBits == 0) {
|
|
// Not initialized.
|
|
return true;
|
|
}
|
|
for (uint32_t i = 0; i < kNumProbes; ++i) {
|
|
const uint32_t bitpos = h % kTotalBits;
|
|
if (((data_[bitpos / 8]) & (1 << (bitpos % 8))) == 0) {
|
|
return false;
|
|
}
|
|
h += delta;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline void DynamicBloom::AddHash(uint32_t h) {
|
|
assert(kNumBlocks > 0 || kTotalBits > 0);
|
|
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
|
|
if (kNumBlocks != 0) {
|
|
uint32_t b = ((h >> 11 | (h << 21)) % kNumBlocks) * (CACHE_LINE_SIZE * 8);
|
|
for (uint32_t i = 0; i < kNumProbes; ++i) {
|
|
// Since CACHE_LINE_SIZE is defined as 2^n, this line will be optimized
|
|
// to a simple and operation by compiler.
|
|
const uint32_t bitpos = b + (h % (CACHE_LINE_SIZE * 8));
|
|
data_[bitpos / 8] |= (1 << (bitpos % 8));
|
|
// Rotate h so that we don't reuse the same bytes.
|
|
h = h / (CACHE_LINE_SIZE * 8) +
|
|
(h % (CACHE_LINE_SIZE * 8)) * (0x20000000U / CACHE_LINE_SIZE);
|
|
h += delta;
|
|
}
|
|
} else {
|
|
for (uint32_t i = 0; i < kNumProbes; ++i) {
|
|
const uint32_t bitpos = h % kTotalBits;
|
|
data_[bitpos / 8] |= (1 << (bitpos % 8));
|
|
h += delta;
|
|
}
|
|
}
|
|
}
|
|
|
|
} // rocksdb
|