1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
  2/*
  3 * uprobe.c
  4 *
  5 * uprobe benchmarks
  6 *
  7 *  Copyright (C) 2023, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  8 */
  9#include "../perf.h"
 10#include "../util/util.h"
 11#include <subcmd/parse-options.h>
 12#include "../builtin.h"
 13#include "bench.h"
 14#include <linux/compiler.h>
 15#include <linux/time64.h>
 16
 17#include <inttypes.h>
 18#include <stdio.h>
 19#include <sys/time.h>
 20#include <sys/types.h>
 21#include <time.h>
 22#include <unistd.h>
 23#include <stdlib.h>
 24
 25#define LOOPS_DEFAULT 1000
 26static int loops = LOOPS_DEFAULT;
 27
 28enum bench_uprobe {
 29        BENCH_UPROBE__BASELINE,
 30        BENCH_UPROBE__EMPTY,
 31        BENCH_UPROBE__TRACE_PRINTK,
 32};
 33
 34static const struct option options[] = {
 35	OPT_INTEGER('l', "loop",	&loops,		"Specify number of loops"),
 36	OPT_END()
 37};
 38
 39static const char * const bench_uprobe_usage[] = {
 40	"perf bench uprobe <options>",
 41	NULL
 42};
 43
 44#ifdef HAVE_BPF_SKEL
 45#include "bpf_skel/bench_uprobe.skel.h"
 46
 47#define bench_uprobe__attach_uprobe(prog) \
 48	skel->links.prog = bpf_program__attach_uprobe_opts(/*prog=*/skel->progs.prog, \
 49							   /*pid=*/-1, \
 50							   /*binary_path=*/"/lib64/libc.so.6", \
 51							   /*func_offset=*/0, \
 52							   /*opts=*/&uprobe_opts); \
 53	if (!skel->links.prog) { \
 54		err = -errno; \
 55		fprintf(stderr, "Failed to attach bench uprobe \"%s\": %s\n", #prog, strerror(errno)); \
 56		goto cleanup; \
 57	}
 58
 59struct bench_uprobe_bpf *skel;
 60
 61static int bench_uprobe__setup_bpf_skel(enum bench_uprobe bench)
 62{
 63	DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, uprobe_opts);
 64	int err;
 65
 66	/* Load and verify BPF application */
 67	skel = bench_uprobe_bpf__open();
 68	if (!skel) {
 69		fprintf(stderr, "Failed to open and load uprobes bench BPF skeleton\n");
 70		return -1;
 71	}
 72
 73	err = bench_uprobe_bpf__load(skel);
 74	if (err) {
 75		fprintf(stderr, "Failed to load and verify BPF skeleton\n");
 76		goto cleanup;
 77	}
 78
 79	uprobe_opts.func_name = "usleep";
 80	switch (bench) {
 81	case BENCH_UPROBE__BASELINE:							break;
 82	case BENCH_UPROBE__EMPTY:	 bench_uprobe__attach_uprobe(empty);		break;
 83	case BENCH_UPROBE__TRACE_PRINTK: bench_uprobe__attach_uprobe(trace_printk);	break;
 84	default:
 85		fprintf(stderr, "Invalid bench: %d\n", bench);
 86		goto cleanup;
 87	}
 88
 89	return err;
 90cleanup:
 91	bench_uprobe_bpf__destroy(skel);
 92	skel = NULL;
 93	return err;
 94}
 95
 96static void bench_uprobe__teardown_bpf_skel(void)
 97{
 98	if (skel) {
 99		bench_uprobe_bpf__destroy(skel);
100		skel = NULL;
101	}
102}
103#else
104static int bench_uprobe__setup_bpf_skel(enum bench_uprobe bench __maybe_unused) { return 0; }
105static void bench_uprobe__teardown_bpf_skel(void) {};
106#endif
107
108static int bench_uprobe_format__default_fprintf(const char *name, const char *unit, u64 diff, FILE *fp)
109{
110	static u64 baseline, previous;
111	s64 diff_to_baseline = diff - baseline,
112	    diff_to_previous = diff - previous;
113	int printed = fprintf(fp, "# Executed %'d %s calls\n", loops, name);
114
115	printed += fprintf(fp, " %14s: %'" PRIu64 " %ss", "Total time", diff, unit);
116
117	if (baseline) {
118		printed += fprintf(fp, " %s%'" PRId64 " to baseline", diff_to_baseline > 0 ? "+" : "", diff_to_baseline);
119
120		if (previous != baseline)
121			fprintf(stdout, " %s%'" PRId64 " to previous", diff_to_previous > 0 ? "+" : "", diff_to_previous);
122	}
123
124	printed += fprintf(fp, "\n\n %'.3f %ss/op", (double)diff / (double)loops, unit);
125
126	if (baseline) {
127		printed += fprintf(fp, " %'.3f %ss/op to baseline", (double)diff_to_baseline / (double)loops, unit);
128
129		if (previous != baseline)
130			printed += fprintf(fp, " %'.3f %ss/op to previous", (double)diff_to_previous / (double)loops, unit);
131	} else {
132		baseline = diff;
133	}
134
135	fputc('\n', fp);
136
137	previous = diff;
138
139	return printed + 1;
140}
141
142static int bench_uprobe(int argc, const char **argv, enum bench_uprobe bench)
143{
144	const char *name = "usleep(1000)", *unit = "usec";
145	struct timespec start, end;
146	u64 diff;
147	int i;
148
149	argc = parse_options(argc, argv, options, bench_uprobe_usage, 0);
150
151	if (bench != BENCH_UPROBE__BASELINE && bench_uprobe__setup_bpf_skel(bench) < 0)
152		return 0;
153
154        clock_gettime(CLOCK_REALTIME, &start);
155
156	for (i = 0; i < loops; i++) {
157		usleep(USEC_PER_MSEC);
158	}
159
160	clock_gettime(CLOCK_REALTIME, &end);
161
162	diff = end.tv_sec * NSEC_PER_SEC + end.tv_nsec - (start.tv_sec * NSEC_PER_SEC + start.tv_nsec);
163	diff /= NSEC_PER_USEC;
164
165	switch (bench_format) {
166	case BENCH_FORMAT_DEFAULT:
167		bench_uprobe_format__default_fprintf(name, unit, diff, stdout);
168		break;
169
170	case BENCH_FORMAT_SIMPLE:
171		printf("%" PRIu64 "\n", diff);
172		break;
173
174	default:
175		/* reaching here is something of a disaster */
176		fprintf(stderr, "Unknown format:%d\n", bench_format);
177		exit(1);
178	}
179
180	if (bench != BENCH_UPROBE__BASELINE)
181		bench_uprobe__teardown_bpf_skel();
182
183	return 0;
184}
185
186int bench_uprobe_baseline(int argc, const char **argv)
187{
188	return bench_uprobe(argc, argv, BENCH_UPROBE__BASELINE);
189}
190
191int bench_uprobe_empty(int argc, const char **argv)
192{
193	return bench_uprobe(argc, argv, BENCH_UPROBE__EMPTY);
194}
195
196int bench_uprobe_trace_printk(int argc, const char **argv)
197{
198	return bench_uprobe(argc, argv, BENCH_UPROBE__TRACE_PRINTK);
199}