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

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */

#include "bench.h"
#include "bench_bpf_timing.h"
#include "bpf_nop_bench.skel.h"
#include "bpf_util.h"

static struct ctx {
	struct bpf_nop_bench *skel;
	struct bpf_bench_timing timing;
	int prog_fd;
} ctx;

static void nop_validate(void)
{
	if (env.consumer_cnt != 0) {
		fprintf(stderr, "benchmark doesn't support consumers\n");
		exit(1);
	}
}

static void nop_run_once(void *unused __always_unused)
{
	LIBBPF_OPTS(bpf_test_run_opts, topts);

	bpf_prog_test_run_opts(ctx.prog_fd, &topts);
}

static void nop_setup(void)
{
	struct bpf_nop_bench *skel;
	int err;

	setup_libbpf();

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

	err = bpf_nop_bench__load(skel);
	if (err) {
		fprintf(stderr, "failed to load skeleton: %s\n", strerror(-err));
		bpf_nop_bench__destroy(skel);
		exit(1);
	}

	ctx.skel = skel;
	ctx.prog_fd = bpf_program__fd(skel->progs.bench_nop);

	BENCH_TIMING_INIT(&ctx.timing, skel, 0);
	bpf_bench_calibrate(&ctx.timing, nop_run_once, NULL);

	env.duration_sec = 600;
}

static void *nop_producer(void *input)
{
	while (true)
		nop_run_once(NULL);

	return NULL;
}

static void nop_measure(struct bench_res *res)
{
	bpf_bench_timing_measure(&ctx.timing, res);
}

static void nop_report_final(struct bench_res res[], int res_cnt)
{
	bpf_bench_timing_report(&ctx.timing, "bpf-nop", NULL);
}

const struct bench bench_bpf_nop = {
	.name		= "bpf-nop",
	.validate	= nop_validate,
	.setup		= nop_setup,
	.producer_thread = nop_producer,
	.measure	= nop_measure,
	.report_final	= nop_report_final,
};