Summary: Adds an improved, replacement Bloom filter implementation (FastLocalBloom) for full and partitioned filters in the block-based table. This replacement is faster and more accurate, especially for high bits per key or millions of keys in a single filter. Speed The improved speed, at least on recent x86_64, comes from * Using fastrange instead of modulo (%) * Using our new hash function (XXH3 preview, added in a previous commit), which is much faster for large keys and only *slightly* slower on keys around 12 bytes if hashing the same size many thousands of times in a row. * Optimizing the Bloom filter queries with AVX2 SIMD operations. (Added AVX2 to the USE_SSE=1 build.) Careful design was required to support (a) SIMD-optimized queries, (b) compatible non-SIMD code that's simple and efficient, (c) flexible choice of number of probes, and (d) essentially maximized accuracy for a cache-local Bloom filter. Probes are made eight at a time, so any number of probes up to 8 is the same speed, then up to 16, etc. * Prefetching cache lines when building the filter. Although this optimization could be applied to the old structure as well, it seems to balance out the small added cost of accumulating 64 bit hashes for adding to the filter rather than 32 bit hashes. Here's nominal speed data from filter_bench (200MB in filters, about 10k keys each, 10 bits filter data / key, 6 probes, avg key size 24 bytes, includes hashing time) on Skylake DE (relatively low clock speed): $ ./filter_bench -quick -impl=2 -net_includes_hashing # New Bloom filter Build avg ns/key: 47.7135 Mixed inside/outside queries... Single filter net ns/op: 26.2825 Random filter net ns/op: 150.459 Average FP rate %: 0.954651 $ ./filter_bench -quick -impl=0 -net_includes_hashing # Old Bloom filter Build avg ns/key: 47.2245 Mixed inside/outside queries... Single filter net ns/op: 63.2978 Random filter net ns/op: 188.038 Average FP rate %: 1.13823 Similar build time but dramatically faster query times on hot data (63 ns to 26 ns), and somewhat faster on stale data (188 ns to 150 ns). Performance differences on batched and skewed query loads are between these extremes as expected. The only other interesting thing about speed is "inside" (query key was added to filter) vs. "outside" (query key was not added to filter) query times. The non-SIMD implementations are substantially slower when most queries are "outside" vs. "inside". This goes against what one might expect or would have observed years ago, as "outside" queries only need about two probes on average, due to short-circuiting, while "inside" always have num_probes (say 6). The problem is probably the nastily unpredictable branch. The SIMD implementation has few branches (very predictable) and has pretty consistent running time regardless of query outcome. Accuracy The generally improved accuracy (re: Issue https://github.com/facebook/rocksdb/issues/5857) comes from a better design for probing indices within a cache line (re: Issue https://github.com/facebook/rocksdb/issues/4120) and improved accuracy for millions of keys in a single filter from using a 64-bit hash function (XXH3p). Design details in code comments. Accuracy data (generalizes, except old impl gets worse with millions of keys): Memory bits per key: FP rate percent old impl -> FP rate percent new impl 6: 5.70953 -> 5.69888 8: 2.45766 -> 2.29709 10: 1.13977 -> 0.959254 12: 0.662498 -> 0.411593 16: 0.353023 -> 0.0873754 24: 0.261552 -> 0.0060971 50: 0.225453 -> ~0.00003 (less than 1 in a million queries are FP) Fixes https://github.com/facebook/rocksdb/issues/5857 Fixes https://github.com/facebook/rocksdb/issues/4120 Unlike the old implementation, this implementation has a fixed cache line size (64 bytes). At 10 bits per key, the accuracy of this new implementation is very close to the old implementation with 128-byte cache line size. If there's sufficient demand, this implementation could be generalized. Compatibility Although old releases would see the new structure as corrupt filter data and read the table as if there's no filter, we've decided only to enable the new Bloom filter with new format_version=5. This provides a smooth path for automatic adoption over time, with an option for early opt-in. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6007 Test Plan: filter_bench has been used thoroughly to validate speed, accuracy, and correctness. Unit tests have been carefully updated to exercise new and old implementations, as well as the logic to select an implementation based on context (format_version). Differential Revision: D18294749 Pulled By: pdillinger fbshipit-source-id: d44c9db3696e4d0a17caaec47075b7755c262c5f
134 lines
5.2 KiB
C++
134 lines
5.2 KiB
C++
// 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) 2012 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
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "rocksdb/filter_policy.h"
|
|
#include "rocksdb/table.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
class Slice;
|
|
|
|
// Exposes any extra information needed for testing built-in
|
|
// FilterBitsBuilders
|
|
class BuiltinFilterBitsBuilder : public FilterBitsBuilder {
|
|
public:
|
|
// Calculate number of bytes needed for a new filter, including
|
|
// metadata. Passing the result to CalculateNumEntry should
|
|
// return >= the num_entry passed in.
|
|
virtual uint32_t CalculateSpace(const int num_entry) = 0;
|
|
};
|
|
|
|
// Current information passed to BloomFilterPolicy at filter building
|
|
// time. Subject to change.
|
|
struct FilterBuildingContext {
|
|
explicit FilterBuildingContext(const BlockBasedTableOptions& table_options)
|
|
: table_options_(table_options) {}
|
|
|
|
// A convenience function to save boilerplate
|
|
FilterBitsBuilder* GetBuilder() const {
|
|
if (table_options_.filter_policy) {
|
|
return table_options_.filter_policy->GetFilterBitsBuilderInternal(*this);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const BlockBasedTableOptions& table_options_;
|
|
};
|
|
|
|
// RocksDB built-in filter policy for Bloom or Bloom-like filters.
|
|
// This class is considered internal API and subject to change.
|
|
// See NewBloomFilterPolicy.
|
|
class BloomFilterPolicy : public FilterPolicy {
|
|
public:
|
|
// An internal marker for operating modes of BloomFilterPolicy, in terms
|
|
// of selecting an implementation. This makes it easier for tests to track
|
|
// or to walk over the built-in set of Bloom filter implementations. The
|
|
// only variance in BloomFilterPolicy by mode/implementation is in
|
|
// GetFilterBitsBuilder(), so an enum is practical here vs. subclasses.
|
|
//
|
|
// This enum is essentially the union of all the different kinds of return
|
|
// value from GetFilterBitsBuilder, or "underlying implementation", and
|
|
// higher-level modes that choose an underlying implementation based on
|
|
// context information.
|
|
enum Mode {
|
|
// Legacy implementation of Bloom filter for full and partitioned filters.
|
|
// Set to 0 in case of value confusion with bool use_block_based_builder
|
|
// NOTE: TESTING ONLY as this mode does not use best compatible
|
|
// implementation
|
|
kLegacyBloom = 0,
|
|
// Deprecated block-based Bloom filter implementation.
|
|
// Set to 1 in case of value confusion with bool use_block_based_builder
|
|
// NOTE: DEPRECATED but user exposed
|
|
kDeprecatedBlock = 1,
|
|
// A fast, cache-local Bloom filter implementation. See description in
|
|
// FastLocalBloomImpl.
|
|
// NOTE: TESTING ONLY as this mode does not check format_version
|
|
kFastLocalBloom = 2,
|
|
// Automatically choose from the above (except kDeprecatedBlock) based on
|
|
// context at build time, including compatibility with format_version.
|
|
// NOTE: This is currently the only recommended mode that is user exposed.
|
|
kAuto = 100,
|
|
};
|
|
// All the different underlying implementations that a BloomFilterPolicy
|
|
// might use, as a mode that says "always use this implementation."
|
|
// Only appropriate for unit tests.
|
|
static const std::vector<Mode> kAllFixedImpls;
|
|
|
|
// All the different modes of BloomFilterPolicy that are exposed from
|
|
// user APIs. Only appropriate for higher-level unit tests. Integration
|
|
// tests should prefer using NewBloomFilterPolicy (user-exposed).
|
|
static const std::vector<Mode> kAllUserModes;
|
|
|
|
explicit BloomFilterPolicy(int bits_per_key, Mode mode);
|
|
|
|
~BloomFilterPolicy() override;
|
|
|
|
const char* Name() const override;
|
|
|
|
// Deprecated block-based filter only
|
|
void CreateFilter(const Slice* keys, int n, std::string* dst) const override;
|
|
|
|
// Deprecated block-based filter only
|
|
bool KeyMayMatch(const Slice& key, const Slice& bloom_filter) const override;
|
|
|
|
FilterBitsBuilder* GetFilterBitsBuilder() const override;
|
|
|
|
// Read metadata to determine what kind of FilterBitsReader is needed
|
|
// and return a new one. This must successfully process any filter data
|
|
// generated by a built-in FilterBitsBuilder, regardless of the impl
|
|
// chosen for this BloomFilterPolicy. Not compatible with CreateFilter.
|
|
FilterBitsReader* GetFilterBitsReader(const Slice& contents) const override;
|
|
|
|
protected:
|
|
// To use this function, call FilterBuildingContext::GetBuilder().
|
|
//
|
|
// Neither the context nor any objects therein should be saved beyond
|
|
// the call to this function, unless it's shared_ptr.
|
|
FilterBitsBuilder* GetFilterBitsBuilderInternal(
|
|
const FilterBuildingContext&) const override;
|
|
|
|
private:
|
|
int bits_per_key_;
|
|
int num_probes_;
|
|
// Selected mode (a specific implementation or way of selecting an
|
|
// implementation) for building new SST filters.
|
|
Mode mode_;
|
|
|
|
// For newer Bloom filter implementation(s)
|
|
FilterBitsReader* GetBloomBitsReader(const Slice& contents) const;
|
|
};
|
|
|
|
} // namespace rocksdb
|