-
Notifications
You must be signed in to change notification settings - Fork 94
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge branch 'Implement bloom filter map'
Joanne Koong says: ==================== This patchset adds a new kind of bpf map: the bloom filter map. Bloom filters are a space-efficient probabilistic data structure used to quickly test whether an element exists in a set. For a brief overview about how bloom filters work, https://en.wikipedia.org/wiki/Bloom_filter may be helpful. One example use-case is an application leveraging a bloom filter map to determine whether a computationally expensive hashmap lookup can be avoided. If the element was not found in the bloom filter map, the hashmap lookup can be skipped. This patchset includes benchmarks for testing the performance of the bloom filter for different entry sizes and different number of hash functions used, as well as comparisons for hashmap lookups with vs. without the bloom filter. A high level overview of this patchset is as follows: 1/5 - kernel changes for adding bloom filter map 2/5 - libbpf changes for adding map_extra flags 3/5 - tests for the bloom filter map 4/5 - benchmarks for bloom filter lookup/update throughput and false positive rate 5/5 - benchmarks for how hashmap lookups perform with vs. without the bloom filter v5 -> v6: * in 1/5: remove "inline" from the hash function, add check in syscall to fail out in cases where map_extra is not 0 for non-bloom-filter maps, fix alignment matching issues, move "map_extra flags" comments to inside the bpf_attr struct, add bpf_map_info map_extra changes here, add map_extra assignment in bpf_map_get_info_by_fd, change hash value_size to u32 instead of a u64 * in 2/5: remove bpf_map_info map_extra changes, remove TODO comment about extending BTF arrays to cover u64s, cast to unsigned long long for %llx when printing out map_extra flags * in 3/5: use __type(value, ...) instead of __uint(value_size, ...) for values and keys * in 4/5: fix wrong bounds for the index when iterating through random values, update commit message to include update+lookup benchmark results for 8 byte and 64-byte value sizes, remove explicit global bool initializaton to false for hashmap_use_bloom and count_false_hits variables v4 -> v5: * Change the "bitset map with bloom filter capabilities" to a bloom filter map with max_entries signifying the number of unique entries expected in the bloom filter, remove bitset tests * Reduce verbiage by changing "bloom_filter" to "bloom", and renaming progs to more concise names. * in 2/5: remove "map_extra" from struct definitions that are frozen, create a "bpf_create_map_params" struct to propagate map_extra to the kernel at map creation time, change map_extra to __u64 * in 4/5: check pthread condition variable in a loop when generating initial map data, remove "err" checks where not pragmatic, generate random values for the hashmap in the setup() instead of in the bpf program, add check_args() for checking that there aren't more requested entries than possible unique entries for the specified value size * in 5/5: Update commit message with updated benchmark data v3 -> v4: * Generalize the bloom filter map to be a bitset map with bloom filter capabilities * Add map_extra flags; pass in nr_hash_funcs through lower 4 bits of map_extra for the bitset map * Add tests for the bitset map (non-bloom filter) functionality * In the benchmarks, stats are computed only as monotonic increases, and place stats in a struct instead of as a percpu_array bpf map v2 -> v3: * Add libbpf changes for supporting nr_hash_funcs, instead of passing the number of hash functions through map_flags. * Separate the hashing logic in kernel/bpf/bloom_filter.c into a helper function v1 -> v2: * Remove libbpf changes, and pass the number of hash functions through map_flags instead. * Default to using 5 hash functions if no number of hash functions is specified. * Use set_bit instead of spinlocks in the bloom filter bitmap. This improved the speed significantly. For example, using 5 hash functions with 100k entries, there was roughly a 35% speed increase. * Use jhash2 (instead of jhash) for u32-aligned value sizes. This increased the speed by roughly 5 to 15%. When using jhash2 on value sizes non-u32 aligned (truncating any remainder bits), there was not a noticeable difference. * Add test for using the bloom filter as an inner map. * Reran the benchmarks, updated the commit messages to correspond to the new results. ==================== Acked-by: Martin KaFai Lau <kafai@fb.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org>
- Loading branch information
Showing
25 changed files
with
1,429 additions
and
51 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,195 @@ | ||
| // SPDX-License-Identifier: GPL-2.0 | ||
| /* Copyright (c) 2021 Facebook */ | ||
|
|
||
| #include <linux/bitmap.h> | ||
| #include <linux/bpf.h> | ||
| #include <linux/btf.h> | ||
| #include <linux/err.h> | ||
| #include <linux/jhash.h> | ||
| #include <linux/random.h> | ||
|
|
||
| #define BLOOM_CREATE_FLAG_MASK \ | ||
| (BPF_F_NUMA_NODE | BPF_F_ZERO_SEED | BPF_F_ACCESS_MASK) | ||
|
|
||
| struct bpf_bloom_filter { | ||
| struct bpf_map map; | ||
| u32 bitset_mask; | ||
| u32 hash_seed; | ||
| /* If the size of the values in the bloom filter is u32 aligned, | ||
| * then it is more performant to use jhash2 as the underlying hash | ||
| * function, else we use jhash. This tracks the number of u32s | ||
| * in an u32-aligned value size. If the value size is not u32 aligned, | ||
| * this will be 0. | ||
| */ | ||
| u32 aligned_u32_count; | ||
| u32 nr_hash_funcs; | ||
| unsigned long bitset[]; | ||
| }; | ||
|
|
||
| static u32 hash(struct bpf_bloom_filter *bloom, void *value, | ||
| u32 value_size, u32 index) | ||
| { | ||
| u32 h; | ||
|
|
||
| if (bloom->aligned_u32_count) | ||
| h = jhash2(value, bloom->aligned_u32_count, | ||
| bloom->hash_seed + index); | ||
| else | ||
| h = jhash(value, value_size, bloom->hash_seed + index); | ||
|
|
||
| return h & bloom->bitset_mask; | ||
| } | ||
|
|
||
| static int peek_elem(struct bpf_map *map, void *value) | ||
| { | ||
| struct bpf_bloom_filter *bloom = | ||
| container_of(map, struct bpf_bloom_filter, map); | ||
| u32 i, h; | ||
|
|
||
| for (i = 0; i < bloom->nr_hash_funcs; i++) { | ||
| h = hash(bloom, value, map->value_size, i); | ||
| if (!test_bit(h, bloom->bitset)) | ||
| return -ENOENT; | ||
| } | ||
|
|
||
| return 0; | ||
| } | ||
|
|
||
| static int push_elem(struct bpf_map *map, void *value, u64 flags) | ||
| { | ||
| struct bpf_bloom_filter *bloom = | ||
| container_of(map, struct bpf_bloom_filter, map); | ||
| u32 i, h; | ||
|
|
||
| if (flags != BPF_ANY) | ||
| return -EINVAL; | ||
|
|
||
| for (i = 0; i < bloom->nr_hash_funcs; i++) { | ||
| h = hash(bloom, value, map->value_size, i); | ||
| set_bit(h, bloom->bitset); | ||
| } | ||
|
|
||
| return 0; | ||
| } | ||
|
|
||
| static int pop_elem(struct bpf_map *map, void *value) | ||
| { | ||
| return -EOPNOTSUPP; | ||
| } | ||
|
|
||
| static struct bpf_map *map_alloc(union bpf_attr *attr) | ||
| { | ||
| u32 bitset_bytes, bitset_mask, nr_hash_funcs, nr_bits; | ||
| int numa_node = bpf_map_attr_numa_node(attr); | ||
| struct bpf_bloom_filter *bloom; | ||
|
|
||
| if (!bpf_capable()) | ||
| return ERR_PTR(-EPERM); | ||
|
|
||
| if (attr->key_size != 0 || attr->value_size == 0 || | ||
| attr->max_entries == 0 || | ||
| attr->map_flags & ~BLOOM_CREATE_FLAG_MASK || | ||
| !bpf_map_flags_access_ok(attr->map_flags) || | ||
| (attr->map_extra & ~0xF)) | ||
| return ERR_PTR(-EINVAL); | ||
|
|
||
| /* The lower 4 bits of map_extra specify the number of hash functions */ | ||
| nr_hash_funcs = attr->map_extra & 0xF; | ||
| if (nr_hash_funcs == 0) | ||
| /* Default to using 5 hash functions if unspecified */ | ||
| nr_hash_funcs = 5; | ||
|
|
||
| /* For the bloom filter, the optimal bit array size that minimizes the | ||
| * false positive probability is n * k / ln(2) where n is the number of | ||
| * expected entries in the bloom filter and k is the number of hash | ||
| * functions. We use 7 / 5 to approximate 1 / ln(2). | ||
| * | ||
| * We round this up to the nearest power of two to enable more efficient | ||
| * hashing using bitmasks. The bitmask will be the bit array size - 1. | ||
| * | ||
| * If this overflows a u32, the bit array size will have 2^32 (4 | ||
| * GB) bits. | ||
| */ | ||
| if (check_mul_overflow(attr->max_entries, nr_hash_funcs, &nr_bits) || | ||
| check_mul_overflow(nr_bits / 5, (u32)7, &nr_bits) || | ||
| nr_bits > (1UL << 31)) { | ||
| /* The bit array size is 2^32 bits but to avoid overflowing the | ||
| * u32, we use U32_MAX, which will round up to the equivalent | ||
| * number of bytes | ||
| */ | ||
| bitset_bytes = BITS_TO_BYTES(U32_MAX); | ||
| bitset_mask = U32_MAX; | ||
| } else { | ||
| if (nr_bits <= BITS_PER_LONG) | ||
| nr_bits = BITS_PER_LONG; | ||
| else | ||
| nr_bits = roundup_pow_of_two(nr_bits); | ||
| bitset_bytes = BITS_TO_BYTES(nr_bits); | ||
| bitset_mask = nr_bits - 1; | ||
| } | ||
|
|
||
| bitset_bytes = roundup(bitset_bytes, sizeof(unsigned long)); | ||
| bloom = bpf_map_area_alloc(sizeof(*bloom) + bitset_bytes, numa_node); | ||
|
|
||
| if (!bloom) | ||
| return ERR_PTR(-ENOMEM); | ||
|
|
||
| bpf_map_init_from_attr(&bloom->map, attr); | ||
|
|
||
| bloom->nr_hash_funcs = nr_hash_funcs; | ||
| bloom->bitset_mask = bitset_mask; | ||
|
|
||
| /* Check whether the value size is u32-aligned */ | ||
| if ((attr->value_size & (sizeof(u32) - 1)) == 0) | ||
| bloom->aligned_u32_count = | ||
| attr->value_size / sizeof(u32); | ||
|
|
||
| if (!(attr->map_flags & BPF_F_ZERO_SEED)) | ||
| bloom->hash_seed = get_random_int(); | ||
|
|
||
| return &bloom->map; | ||
| } | ||
|
|
||
| static void map_free(struct bpf_map *map) | ||
| { | ||
| struct bpf_bloom_filter *bloom = | ||
| container_of(map, struct bpf_bloom_filter, map); | ||
|
|
||
| bpf_map_area_free(bloom); | ||
| } | ||
|
|
||
| static void *lookup_elem(struct bpf_map *map, void *key) | ||
| { | ||
| /* The eBPF program should use map_peek_elem instead */ | ||
| return ERR_PTR(-EINVAL); | ||
| } | ||
|
|
||
| static int update_elem(struct bpf_map *map, void *key, | ||
| void *value, u64 flags) | ||
| { | ||
| /* The eBPF program should use map_push_elem instead */ | ||
| return -EINVAL; | ||
| } | ||
|
|
||
| static int check_btf(const struct bpf_map *map, const struct btf *btf, | ||
| const struct btf_type *key_type, | ||
| const struct btf_type *value_type) | ||
| { | ||
| /* Bloom filter maps are keyless */ | ||
| return btf_type_is_void(key_type) ? 0 : -EINVAL; | ||
| } | ||
|
|
||
| static int bpf_bloom_btf_id; | ||
| const struct bpf_map_ops bloom_filter_map_ops = { | ||
| .map_meta_equal = bpf_map_meta_equal, | ||
| .map_alloc = map_alloc, | ||
| .map_free = map_free, | ||
| .map_push_elem = push_elem, | ||
| .map_peek_elem = peek_elem, | ||
| .map_pop_elem = pop_elem, | ||
| .map_lookup_elem = lookup_elem, | ||
| .map_update_elem = update_elem, | ||
| .map_check_btf = check_btf, | ||
| .map_btf_name = "bpf_bloom_filter", | ||
| .map_btf_id = &bpf_bloom_btf_id, | ||
| }; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.