布隆过滤器使用bit数组映射关键字key,对于在一个超大的集合中判断是否存在某个key能够起到很好的效果。但是缺点很明显:容易误报。也就是本来不存在的key,可能告诉你它存在。
一、布隆过滤器
根据上图来说明布隆过滤器的原理 :
1)布隆过滤有一个m位(这里是10个)的bit数组(或者称bitmap),bit数组初始化为全0,并且有k个(这里是3个)hash函数。
2)当我们分别存储abc,hello,world三个关键字,然后分别对这些key进行hash(每个hash都执行),得出结果如上图第三张表所示,然后对bit数组对应的bit位置1,置1后的结果如第二张表所示。
3)当我们对现有数据进行查询的时候,比如查询myworld,经过hash计算后得出0, 2,7,我们发现bit数组下标为2时,这一位为0,说明myworld一定不存在。再比如查询myabc,经过hash计算后得出0, 5,7,经过bit数组对比,发现0,5,7都是1,但是myabc却不存在,所以myabc属于误报!
总结:
1)布隆过滤器,对于不存在关键值能给出肯定结果,但是对于存在关键值只能说可能存在(存在一定误报)。这个主要是因为hash函数特征所决定的。
2)对于那么如何确定是否真的存在还是误报呢?应该交给业务模块再次进行确定查找。
3)如果保证误报率最低呢?有一个公式:k = (m/n)*ln2。(k为hash函数个数,m为bit数组大小,n为插入元素个数,ln2约等于0.69),当存在k个hash函数时误报率最低。至于为什么是这个公式,大家可自行查询相关资料。
二、leveldb中的布隆过滤器
2.1、构造方法
private:
size_t bits_per_key_;
size_t k_; /* 表示需要k_个hash函数 最大30个*/
public:
explicit BloomFilterPolicy(int bits_per_key)
: bits_per_key_(bits_per_key) {
// We intentionally round down to reduce probing cost a little bit
k_ = static_cast<size_t>(bits_per_key * 0.69); // 0.69 =~ ln(2)
if (k_ < 1) k_ = 1;
if (k_ > 30) k_ = 30;
}
2.2、CreateFilter
/**
* 生成过滤器
* @param keys 数组
* @param n 数组keys元素个数
* @param dst 保存bitmap
*/
virtual void CreateFilter(const Slice* keys, int n, std::string* dst) const {
// Compute bloom filter size (in both bits and bytes)
size_t bits = n * bits_per_key_; //表示bit数组中包含多少位
// For small n, we can see a very high false positive rate. Fix it
// by enforcing a minimum bloom filter length.
if (bits < 64) bits = 64;//避免误报率过高
size_t bytes = (bits + 7) / 8;//8bit对齐
bits = bytes * 8;
const size_t init_size = dst->size();
dst->resize(init_size + bytes, 0);
dst->push_back(static_cast<char>(k_)); // Remember # of probes in filter
char* array = &(*dst)[init_size];
for (int i = 0; i < n; i++) {
// Use double-hashing to generate a sequence of hash values.
// See analysis in [Kirsch,Mitzenmacher 2006].
// 对一个key进行两次hash
uint32_t h = BloomHash(keys[i]);
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
//对于一个hash值(这里的hash可能很大数字),通过for循环模拟k个hash场景
for (size_t j = 0; j < k_; j++) {
const uint32_t bitpos = h % bits;//对bit数组求余 获取存储的bit
array[bitpos/8] |= (1 << (bitpos % 8));
h += delta;
}
}
}
2.3、KeyMayMatch
/**
* 匹配key是存在当前过滤器中
* @param key 关键值
* @param bloom_filter 过滤器
* @return false 表示不存在
* true 表示key可能存在 是否真的存在还需要对key进行比较
*/
virtual bool KeyMayMatch(const Slice& key, const Slice& bloom_filter) const {
const size_t len = bloom_filter.size();
if (len < 2) return false;
const char* array = bloom_filter.data();
const size_t bits = (len - 1) * 8;
// Use the encoded k so that we can read filters generated by
// bloom filters created using different parameters.
const size_t k = array[len-1];
if (k > 30) {
// Reserved for potentially new encodings for short bloom filters.
// Consider it a match.
return true;
}
uint32_t h = BloomHash(key);
const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits
for (size_t j = 0; j < k; j++) {
const uint32_t bitpos = h % bits;
if ((array[bitpos/8] & (1 << (bitpos % 8))) == 0) return false;
h += delta;
}
return true;
}
三、布隆过滤器在leveldb中的应用
那么布隆过滤器在leveldb应用到什么方面呢?看过之前的博客,应该有印象的,在介绍存储结构中一个的block叫做filter block。这部分处理就是布隆过滤器应用之处,可参考《leveldb深度剖析-存储结构(2)》。下面具体看看是如何应用的。
3.1、开启过滤策略
leveldb接口默认不开启过滤策略(不是很清楚为啥?),在创建对象Options时候指定了为NULL(options.cc)。
Options::Options()
: comparator(BytewiseComparator()),
create_if_missing(false),
error_if_exists(false),
paranoid_checks(false),
env(Env::Default()),
info_log(NULL),
write_buffer_size(4<<20), // 4M
max_open_files(1000),
block_cache(NULL),
block_size(4096),
block_restart_interval(16), //重启点间隔为16
max_file_size(2<<20), //2M
compression(kSnappyCompression),
reuse_logs(false),
filter_policy(NULL) {
}
所以我们在创建Options对象需要单独设置一下filter_policy对象才可以。
3.2、添加key
std::string keys_; // Flattened key contents
std::vector<size_t> start_; // Starting index in keys_ of each key
/**
* 将key添加到FilterBlock中
* @param key InternalKey 不包含value
*/
void FilterBlockBuilder::AddKey(const Slice& key) {
Slice k = key;
start_.push_back(keys_.size());//记录每个key的偏移位置
keys_.append(k.data(), k.size());//将key追加到字符串keys_末尾
}
3.3、Finish
Finish主要是格式化之前保存的key的,这里就会涉及布隆过滤器的。
Slice FilterBlockBuilder::Finish() {
if (!start_.empty()) {
GenerateFilter();//生成过滤器数据
}
// Append array of per-filter offsets
// 经过上面GenerateFilter操作后result_保存操作结果
const uint32_t array_offset = result_.size();
for (size_t i = 0; i < filter_offsets_.size(); i++) {
PutFixed32(&result_, filter_offsets_[i]);
}
PutFixed32(&result_, array_offset);
result_.push_back(kFilterBaseLg); // Save encoding parameter in result
return Slice(result_);//返回后 写入ldb文件
}
3.4、GenerateFilter
void FilterBlockBuilder::GenerateFilter() {
const size_t num_keys = start_.size();//start_保存这这个block存储的key 多个
if (num_keys == 0) {
// Fast path if there are no keys for this filter
filter_offsets_.push_back(result_.size());
return;
}
// Make list of keys from flattened key structure
start_.push_back(keys_.size()); // Simplify length computation
tmp_keys_.resize(num_keys);
for (size_t i = 0; i < num_keys; i++) {
const char* base = keys_.data() + start_[i];
size_t length = start_[i+1] - start_[i];
tmp_keys_[i] = Slice(base, length);
}
// Generate filter for current set of keys and append to result_.
// 调用布隆过滤器生成数据
filter_offsets_.push_back(result_.size());
policy_->CreateFilter(&tmp_keys_[0], static_cast<int>(num_keys), &result_);
tmp_keys_.clear();
keys_.clear();
start_.clear();
}
3.5、查找匹配
查询的时候需要创建FilterBlockReader对象才可以进行查询,调用FilterBlockReader的KeyMayMatch方法即可,具体如下:
bool FilterBlockReader::KeyMayMatch(uint64_t block_offset, const Slice& key) {
uint64_t index = block_offset >> base_lg_;
if (index < num_) {
uint32_t start = DecodeFixed32(offset_ + index*4);
uint32_t limit = DecodeFixed32(offset_ + index*4 + 4);
if (start <= limit && limit <= static_cast<size_t>(offset_ - data_)) {
Slice filter = Slice(data_ + start, limit - start);
return policy_->KeyMayMatch(key, filter);//InternalFilterPolicy::KeyMayMatch 布隆过滤器
} else if (start == limit) {
// Empty filters do not match any keys
return false;
}
}
return true; // Errors are treated as potential matches
}
这里就很明显是调用布隆过滤器进行查询匹配。那么上层业务是如何调到这里呢?
/**
* 在table cache中查找k
* @param options 选项
* @param k 待查找key
* @param arg 回调函数参数
* @param saver 回调函数
*/
Status Table::InternalGet(const ReadOptions& options, const Slice& k,
void* arg,
void (*saver)(void*, const Slice&, const Slice&)) {
Status s;
Iterator* iiter = rep_->index_block->NewIterator(rep_->options.comparator);//这里index_block类型是Block
iiter->Seek(k);//查找 在索引块中查找 Block.cc
if (iiter->Valid()) {
Slice handle_value = iiter->value();
FilterBlockReader* filter = rep_->filter;
BlockHandle handle;
/**
* 如果存在过滤模块 则先在过滤模块中通过布隆过滤器进行确定 如果布隆过滤器不存在 那么文件中一定不存在
* if 返回true表示不存在,if返回false表示可能存在 需要再次进行文件中查找即进入else中
*/
if (filter != NULL &&
handle.DecodeFrom(&handle_value).ok() &&
!filter->KeyMayMatch(handle.offset(), k)) {
// Not found
} else {//在数据块中进行查找 iiter->value存储的是BlockHandle
Iterator* block_iter = BlockReader(this, options, iiter->value());
block_iter->Seek(k);
if (block_iter->Valid()) {//表示找到
(*saver)(arg, block_iter->key(), block_iter->value());
}
s = block_iter->status();
delete block_iter;
}
}
if (s.ok()) {
s = iiter->status();
}
delete iiter;
return s;
}
四、总结
其实布隆过滤器思想比较简单,我们需要了解相关特性即可。