bpf/benchs: Add benchmark tests for bloom filter throughput + false positive (57fd1c63) · Commits · EulixOS / Software / Kernel

tools/testing/selftests/bpf/Makefile

+4 −2

Original line number	Diff line number	Diff line
		@@ -524,18 +524,20 @@ $(OUTPUT)/test_cpp: test_cpp.cpp $(OUTPUT)/test_core_extern.skel.h $(BPFOBJ)
		# Benchmark runner
		$(OUTPUT)/bench_%.o: benchs/bench_%.c bench.h $(BPFOBJ)
		$(call msg,CC,,$@)
		$(Q)$(CC) $(CFLAGS) -c $(filter %.c,$^) $(LDLIBS) -o $@
		$(Q)$(CC) $(CFLAGS) -O2 -c $(filter %.c,$^) $(LDLIBS) -o $@
		$(OUTPUT)/bench_rename.o: $(OUTPUT)/test_overhead.skel.h
		$(OUTPUT)/bench_trigger.o: $(OUTPUT)/trigger_bench.skel.h
		$(OUTPUT)/bench_ringbufs.o: $(OUTPUT)/ringbuf_bench.skel.h \
		$(OUTPUT)/perfbuf_bench.skel.h
		$(OUTPUT)/bench_bloom_filter_map.o: $(OUTPUT)/bloom_filter_bench.skel.h
		$(OUTPUT)/bench.o: bench.h testing_helpers.h $(BPFOBJ)
		$(OUTPUT)/bench: LDLIBS += -lm
		$(OUTPUT)/bench: $(OUTPUT)/bench.o $(OUTPUT)/testing_helpers.o \
		$(OUTPUT)/bench_count.o \
		$(OUTPUT)/bench_rename.o \
		$(OUTPUT)/bench_trigger.o \
		$(OUTPUT)/bench_ringbufs.o
		$(OUTPUT)/bench_ringbufs.o \
		$(OUTPUT)/bench_bloom_filter_map.o
		$(call msg,BINARY,,$@)
		$(Q)$(CC) $(LDFLAGS) -o $@ $(filter %.a %.o,$^) $(LDLIBS)

tools/testing/selftests/bpf/bench.c

+37 −0

Original line number	Diff line number	Diff line
		@@ -51,6 +51,35 @@ void setup_libbpf()
		fprintf(stderr, "failed to increase RLIMIT_MEMLOCK: %d", err);
		}

		void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns)
		{
		long total = res->false_hits + res->hits + res->drops;

		printf("Iter %3d (%7.3lfus): ",
		iter, (delta_ns - 1000000000) / 1000.0);

		printf("%ld false hits of %ld total operations. Percentage = %2.2f %%\n",
		res->false_hits, total, ((float)res->false_hits / total) * 100);
		}

		void false_hits_report_final(struct bench_res res[], int res_cnt)
		{
		long total_hits = 0, total_drops = 0, total_false_hits = 0, total_ops = 0;
		int i;

		for (i = 0; i < res_cnt; i++) {
		total_hits += res[i].hits;
		total_false_hits += res[i].false_hits;
		total_drops += res[i].drops;
		}
		total_ops = total_hits + total_false_hits + total_drops;

		printf("Summary: %ld false hits of %ld total operations. ",
		total_false_hits, total_ops);
		printf("Percentage = %2.2f %%\n",
		((float)total_false_hits / total_ops) * 100);
		}

		void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns)
		{
		double hits_per_sec, drops_per_sec;
		@@ -132,9 +161,11 @@ static const struct argp_option opts[] = {
		};

		extern struct argp bench_ringbufs_argp;
		extern struct argp bench_bloom_map_argp;

		static const struct argp_child bench_parsers[] = {
		{ &bench_ringbufs_argp, 0, "Ring buffers benchmark", 0 },
		{ &bench_bloom_map_argp, 0, "Bloom filter map benchmark", 0 },
		{},
		};

		@@ -323,6 +354,9 @@ extern const struct bench bench_rb_libbpf;
		extern const struct bench bench_rb_custom;
		extern const struct bench bench_pb_libbpf;
		extern const struct bench bench_pb_custom;
		extern const struct bench bench_bloom_lookup;
		extern const struct bench bench_bloom_update;
		extern const struct bench bench_bloom_false_positive;

		static const struct bench *benchs[] = {
		&bench_count_global,
		@@ -344,6 +378,9 @@ static const struct bench *benchs[] = {
		&bench_rb_custom,
		&bench_pb_libbpf,
		&bench_pb_custom,
		&bench_bloom_lookup,
		&bench_bloom_update,
		&bench_bloom_false_positive,
		};

		static void setup_benchmark()

tools/testing/selftests/bpf/bench.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ struct env {
		struct bench_res {
		long hits;
		long drops;
		long false_hits;
		};

		struct bench {
		@@ -56,6 +57,8 @@ extern const struct bench *bench;
		void setup_libbpf();
		void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns);
		void hits_drops_report_final(struct bench_res res[], int res_cnt);
		void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns);
		void false_hits_report_final(struct bench_res res[], int res_cnt);

		static inline __u64 get_time_ns() {
		struct timespec t;

tools/testing/selftests/bpf/benchs/bench_bloom_filter_map.c

0 → 100644

+420 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/* Copyright (c) 2021 Facebook */

		#include <argp.h>
		#include <linux/log2.h>
		#include <pthread.h>
		#include "bench.h"
		#include "bloom_filter_bench.skel.h"
		#include "bpf_util.h"

		static struct ctx {
		bool use_array_map;
		bool use_hashmap;
		bool hashmap_use_bloom;
		bool count_false_hits;

		struct bloom_filter_bench *skel;

		int bloom_fd;
		int hashmap_fd;
		int array_map_fd;

		pthread_mutex_t map_done_mtx;
		pthread_cond_t map_done_cv;
		bool map_done;
		bool map_prepare_err;

		__u32 next_map_idx;
		} ctx = {
		.map_done_mtx = PTHREAD_MUTEX_INITIALIZER,
		.map_done_cv = PTHREAD_COND_INITIALIZER,
		};

		struct stat {
		__u32 stats[3];
		};

		static struct {
		__u32 nr_entries;
		__u8 nr_hash_funcs;
		__u8 value_size;
		} args = {
		.nr_entries = 1000,
		.nr_hash_funcs = 3,
		.value_size = 8,
		};

		enum {
		ARG_NR_ENTRIES = 3000,
		ARG_NR_HASH_FUNCS = 3001,
		ARG_VALUE_SIZE = 3002,
		};

		static const struct argp_option opts[] = {
		{ "nr_entries", ARG_NR_ENTRIES, "NR_ENTRIES", 0,
		"Set number of expected unique entries in the bloom filter"},
		{ "nr_hash_funcs", ARG_NR_HASH_FUNCS, "NR_HASH_FUNCS", 0,
		"Set number of hash functions in the bloom filter"},
		{ "value_size", ARG_VALUE_SIZE, "VALUE_SIZE", 0,
		"Set value size (in bytes) of bloom filter entries"},
		{},
		};

		static error_t parse_arg(int key, char arg, struct argp_state state)
		{
		switch (key) {
		case ARG_NR_ENTRIES:
		args.nr_entries = strtol(arg, NULL, 10);
		if (args.nr_entries == 0) {
		fprintf(stderr, "Invalid nr_entries count.");
		argp_usage(state);
		}
		break;
		case ARG_NR_HASH_FUNCS:
		args.nr_hash_funcs = strtol(arg, NULL, 10);
		if (args.nr_hash_funcs == 0 \|\| args.nr_hash_funcs > 15) {
		fprintf(stderr,
		"The bloom filter must use 1 to 15 hash functions.");
		argp_usage(state);
		}
		break;
		case ARG_VALUE_SIZE:
		args.value_size = strtol(arg, NULL, 10);
		if (args.value_size < 2 \|\| args.value_size > 256) {
		fprintf(stderr,
		"Invalid value size. Must be between 2 and 256 bytes");
		argp_usage(state);
		}
		break;
		default:
		return ARGP_ERR_UNKNOWN;
		}

		return 0;
		}

		/* exported into benchmark runner */
		const struct argp bench_bloom_map_argp = {
		.options = opts,
		.parser = parse_arg,
		};

		static void validate(void)
		{
		if (env.consumer_cnt != 1) {
		fprintf(stderr,
		"The bloom filter benchmarks do not support multi-consumer use\n");
		exit(1);
		}
		}

		static inline void trigger_bpf_program(void)
		{
		syscall(__NR_getpgid);
		}

		static void producer(void input)
		{
		while (true)
		trigger_bpf_program();

		return NULL;
		}

		static void map_prepare_thread(void arg)
		{
		__u32 val_size, i;
		void *val = NULL;
		int err;

		val_size = args.value_size;
		val = malloc(val_size);
		if (!val) {
		ctx.map_prepare_err = true;
		goto done;
		}

		while (true) {
		i = __atomic_add_fetch(&ctx.next_map_idx, 1, __ATOMIC_RELAXED);
		if (i > args.nr_entries)
		break;

		again:
		/* Populate hashmap, bloom filter map, and array map with the same
		* random values
		*/
		err = syscall(__NR_getrandom, val, val_size, 0);
		if (err != val_size) {
		ctx.map_prepare_err = true;
		fprintf(stderr, "failed to get random value: %d\n", -errno);
		break;
		}

		if (ctx.use_hashmap) {
		err = bpf_map_update_elem(ctx.hashmap_fd, val, val, BPF_NOEXIST);
		if (err) {
		if (err != -EEXIST) {
		ctx.map_prepare_err = true;
		fprintf(stderr, "failed to add elem to hashmap: %d\n",
		-errno);
		break;
		}
		goto again;
		}
		}

		i--;

		if (ctx.use_array_map) {
		err = bpf_map_update_elem(ctx.array_map_fd, &i, val, 0);
		if (err) {
		ctx.map_prepare_err = true;
		fprintf(stderr, "failed to add elem to array map: %d\n", -errno);
		break;
		}
		}

		if (ctx.use_hashmap && !ctx.hashmap_use_bloom)
		continue;

		err = bpf_map_update_elem(ctx.bloom_fd, NULL, val, 0);
		if (err) {
		ctx.map_prepare_err = true;
		fprintf(stderr,
		"failed to add elem to bloom filter map: %d\n", -errno);
		break;
		}
		}
		done:
		pthread_mutex_lock(&ctx.map_done_mtx);
		ctx.map_done = true;
		pthread_cond_signal(&ctx.map_done_cv);
		pthread_mutex_unlock(&ctx.map_done_mtx);

		if (val)
		free(val);

		return NULL;
		}

		static void populate_maps(void)
		{
		unsigned int nr_cpus = bpf_num_possible_cpus();
		pthread_t map_thread;
		int i, err, nr_rand_bytes;

		ctx.bloom_fd = bpf_map__fd(ctx.skel->maps.bloom_map);
		ctx.hashmap_fd = bpf_map__fd(ctx.skel->maps.hashmap);
		ctx.array_map_fd = bpf_map__fd(ctx.skel->maps.array_map);

		for (i = 0; i < nr_cpus; i++) {
		err = pthread_create(&map_thread, NULL, map_prepare_thread,
		NULL);
		if (err) {
		fprintf(stderr, "failed to create pthread: %d\n", -errno);
		exit(1);
		}
		}

		pthread_mutex_lock(&ctx.map_done_mtx);
		while (!ctx.map_done)
		pthread_cond_wait(&ctx.map_done_cv, &ctx.map_done_mtx);
		pthread_mutex_unlock(&ctx.map_done_mtx);

		if (ctx.map_prepare_err)
		exit(1);

		nr_rand_bytes = syscall(__NR_getrandom, ctx.skel->bss->rand_vals,
		ctx.skel->rodata->nr_rand_bytes, 0);
		if (nr_rand_bytes != ctx.skel->rodata->nr_rand_bytes) {
		fprintf(stderr, "failed to get random bytes\n");
		exit(1);
		}
		}

		static void check_args(void)
		{
		if (args.value_size < 8) {
		__u64 nr_unique_entries = 1ULL << (args.value_size * 8);

		if (args.nr_entries > nr_unique_entries) {
		fprintf(stderr,
		"Not enough unique values for the nr_entries requested\n");
		exit(1);
		}
		}
		}

		static struct bloom_filter_bench *setup_skeleton(void)
		{
		struct bloom_filter_bench *skel;

		check_args();

		setup_libbpf();

		skel = bloom_filter_bench__open();
		if (!skel) {
		fprintf(stderr, "failed to open skeleton\n");
		exit(1);
		}

		skel->rodata->hashmap_use_bloom = ctx.hashmap_use_bloom;
		skel->rodata->count_false_hits = ctx.count_false_hits;

		/* Resize number of entries */
		bpf_map__set_max_entries(skel->maps.hashmap, args.nr_entries);

		bpf_map__set_max_entries(skel->maps.array_map, args.nr_entries);

		bpf_map__set_max_entries(skel->maps.bloom_map, args.nr_entries);

		/* Set value size */
		bpf_map__set_value_size(skel->maps.array_map, args.value_size);

		bpf_map__set_value_size(skel->maps.bloom_map, args.value_size);

		bpf_map__set_value_size(skel->maps.hashmap, args.value_size);

		/* For the hashmap, we use the value as the key as well */
		bpf_map__set_key_size(skel->maps.hashmap, args.value_size);

		skel->bss->value_size = args.value_size;

		/* Set number of hash functions */
		bpf_map__set_map_extra(skel->maps.bloom_map, args.nr_hash_funcs);

		if (bloom_filter_bench__load(skel)) {
		fprintf(stderr, "failed to load skeleton\n");
		exit(1);
		}

		return skel;
		}

		static void bloom_lookup_setup(void)
		{
		struct bpf_link *link;

		ctx.use_array_map = true;

		ctx.skel = setup_skeleton();

		populate_maps();

		link = bpf_program__attach(ctx.skel->progs.bloom_lookup);
		if (!link) {
		fprintf(stderr, "failed to attach program!\n");
		exit(1);
		}
		}

		static void bloom_update_setup(void)
		{
		struct bpf_link *link;

		ctx.use_array_map = true;

		ctx.skel = setup_skeleton();

		populate_maps();

		link = bpf_program__attach(ctx.skel->progs.bloom_update);
		if (!link) {
		fprintf(stderr, "failed to attach program!\n");
		exit(1);
		}
		}

		static void false_positive_setup(void)
		{
		struct bpf_link *link;

		ctx.use_hashmap = true;
		ctx.hashmap_use_bloom = true;
		ctx.count_false_hits = true;

		ctx.skel = setup_skeleton();

		populate_maps();

		link = bpf_program__attach(ctx.skel->progs.bloom_hashmap_lookup);
		if (!link) {
		fprintf(stderr, "failed to attach program!\n");
		exit(1);
		}
		}

		static void measure(struct bench_res *res)
		{
		unsigned long total_hits = 0, total_drops = 0, total_false_hits = 0;
		static unsigned long last_hits, last_drops, last_false_hits;
		unsigned int nr_cpus = bpf_num_possible_cpus();
		int hit_key, drop_key, false_hit_key;
		int i;

		hit_key = ctx.skel->rodata->hit_key;
		drop_key = ctx.skel->rodata->drop_key;
		false_hit_key = ctx.skel->rodata->false_hit_key;

		if (ctx.skel->bss->error != 0) {
		fprintf(stderr, "error (%d) when searching the bloom filter\n",
		ctx.skel->bss->error);
		exit(1);
		}

		for (i = 0; i < nr_cpus; i++) {
		struct stat s = (void )&ctx.skel->bss->percpu_stats[i];

		total_hits += s->stats[hit_key];
		total_drops += s->stats[drop_key];
		total_false_hits += s->stats[false_hit_key];
		}

		res->hits = total_hits - last_hits;
		res->drops = total_drops - last_drops;
		res->false_hits = total_false_hits - last_false_hits;

		last_hits = total_hits;
		last_drops = total_drops;
		last_false_hits = total_false_hits;
		}

		static void consumer(void input)
		{
		return NULL;
		}

		const struct bench bench_bloom_lookup = {
		.name = "bloom-lookup",
		.validate = validate,
		.setup = bloom_lookup_setup,
		.producer_thread = producer,
		.consumer_thread = consumer,
		.measure = measure,
		.report_progress = hits_drops_report_progress,
		.report_final = hits_drops_report_final,
		};

		const struct bench bench_bloom_update = {
		.name = "bloom-update",
		.validate = validate,
		.setup = bloom_update_setup,
		.producer_thread = producer,
		.consumer_thread = consumer,
		.measure = measure,
		.report_progress = hits_drops_report_progress,
		.report_final = hits_drops_report_final,
		};

		const struct bench bench_bloom_false_positive = {
		.name = "bloom-false-positive",
		.validate = validate,
		.setup = false_positive_setup,
		.producer_thread = producer,
		.consumer_thread = consumer,
		.measure = measure,
		.report_progress = false_hits_report_progress,
		.report_final = false_hits_report_final,
		};

tools/testing/selftests/bpf/benchs/run_bench_bloom_filter_map.sh

0 → 100755

+28 −0

Original line number	Diff line number	Diff line
		#!/bin/bash
		# SPDX-License-Identifier: GPL-2.0

		source ./benchs/run_common.sh

		set -eufo pipefail

		header "Bloom filter map"
		for v in 2 4 8 16 40; do
		for t in 1 4 8 12 16; do
		for h in {1..10}; do
		subtitle "value_size: $v bytes, # threads: $t, # hashes: $h"
		for e in 10000 50000 75000 100000 250000 500000 750000 1000000 2500000 5000000; do
		printf "%'d entries -\n" $e
		printf "\t"
		summarize "Lookups, total operations: " \
		"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-lookup)"
		printf "\t"
		summarize "Updates, total operations: " \
		"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-update)"
		printf "\t"
		summarize_percentage "False positive rate: " \
		"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-false-positive)"
		done
		printf "\n"
		done
		done
		done