Loading...
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 BENCH_UPROBE__EMPTY_RET,
33 BENCH_UPROBE__TRACE_PRINTK_RET,
34};
35
36static const struct option options[] = {
37 OPT_INTEGER('l', "loop", &loops, "Specify number of loops"),
38 OPT_END()
39};
40
41static const char * const bench_uprobe_usage[] = {
42 "perf bench uprobe <options>",
43 NULL
44};
45
46#ifdef HAVE_BPF_SKEL
47#include "bpf_skel/bench_uprobe.skel.h"
48
49#define bench_uprobe__attach_uprobe(prog) \
50 skel->links.prog = bpf_program__attach_uprobe_opts(/*prog=*/skel->progs.prog, \
51 /*pid=*/-1, \
52 /*binary_path=*/"libc.so.6", \
53 /*func_offset=*/0, \
54 /*opts=*/&uprobe_opts); \
55 if (!skel->links.prog) { \
56 err = -errno; \
57 fprintf(stderr, "Failed to attach bench uprobe \"%s\": %s\n", #prog, strerror(errno)); \
58 goto cleanup; \
59 }
60
61struct bench_uprobe_bpf *skel;
62
63static int bench_uprobe__setup_bpf_skel(enum bench_uprobe bench)
64{
65 DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, uprobe_opts);
66 int err;
67
68 /* Load and verify BPF application */
69 skel = bench_uprobe_bpf__open();
70 if (!skel) {
71 fprintf(stderr, "Failed to open and load uprobes bench BPF skeleton\n");
72 return -1;
73 }
74
75 err = bench_uprobe_bpf__load(skel);
76 if (err) {
77 fprintf(stderr, "Failed to load and verify BPF skeleton\n");
78 goto cleanup;
79 }
80
81 uprobe_opts.func_name = "usleep";
82 switch (bench) {
83 case BENCH_UPROBE__BASELINE: break;
84 case BENCH_UPROBE__EMPTY: bench_uprobe__attach_uprobe(empty); break;
85 case BENCH_UPROBE__TRACE_PRINTK: bench_uprobe__attach_uprobe(trace_printk); break;
86 case BENCH_UPROBE__EMPTY_RET: bench_uprobe__attach_uprobe(empty_ret); break;
87 case BENCH_UPROBE__TRACE_PRINTK_RET: bench_uprobe__attach_uprobe(trace_printk_ret); break;
88 default:
89 fprintf(stderr, "Invalid bench: %d\n", bench);
90 goto cleanup;
91 }
92
93 return err;
94cleanup:
95 bench_uprobe_bpf__destroy(skel);
96 skel = NULL;
97 return err;
98}
99
100static void bench_uprobe__teardown_bpf_skel(void)
101{
102 if (skel) {
103 bench_uprobe_bpf__destroy(skel);
104 skel = NULL;
105 }
106}
107#else
108static int bench_uprobe__setup_bpf_skel(enum bench_uprobe bench __maybe_unused) { return 0; }
109static void bench_uprobe__teardown_bpf_skel(void) {};
110#endif
111
112static int bench_uprobe_format__default_fprintf(const char *name, const char *unit, u64 diff, FILE *fp)
113{
114 static u64 baseline, previous;
115 s64 diff_to_baseline = diff - baseline,
116 diff_to_previous = diff - previous;
117 int printed = fprintf(fp, "# Executed %'d %s calls\n", loops, name);
118
119 printed += fprintf(fp, " %14s: %'" PRIu64 " %ss", "Total time", diff, unit);
120
121 if (baseline) {
122 printed += fprintf(fp, " %s%'" PRId64 " to baseline", diff_to_baseline > 0 ? "+" : "", diff_to_baseline);
123
124 if (previous != baseline)
125 fprintf(stdout, " %s%'" PRId64 " to previous", diff_to_previous > 0 ? "+" : "", diff_to_previous);
126 }
127
128 printed += fprintf(fp, "\n\n %'.3f %ss/op", (double)diff / (double)loops, unit);
129
130 if (baseline) {
131 printed += fprintf(fp, " %'.3f %ss/op to baseline", (double)diff_to_baseline / (double)loops, unit);
132
133 if (previous != baseline)
134 printed += fprintf(fp, " %'.3f %ss/op to previous", (double)diff_to_previous / (double)loops, unit);
135 } else {
136 baseline = diff;
137 }
138
139 fputc('\n', fp);
140
141 previous = diff;
142
143 return printed + 1;
144}
145
146static int bench_uprobe(int argc, const char **argv, enum bench_uprobe bench)
147{
148 const char *name = "usleep(1000)", *unit = "usec";
149 struct timespec start, end;
150 u64 diff;
151 int i;
152
153 argc = parse_options(argc, argv, options, bench_uprobe_usage, 0);
154
155 if (bench != BENCH_UPROBE__BASELINE && bench_uprobe__setup_bpf_skel(bench) < 0)
156 return 0;
157
158 clock_gettime(CLOCK_REALTIME, &start);
159
160 for (i = 0; i < loops; i++) {
161 usleep(USEC_PER_MSEC);
162 }
163
164 clock_gettime(CLOCK_REALTIME, &end);
165
166 diff = end.tv_sec * NSEC_PER_SEC + end.tv_nsec - (start.tv_sec * NSEC_PER_SEC + start.tv_nsec);
167 diff /= NSEC_PER_USEC;
168
169 switch (bench_format) {
170 case BENCH_FORMAT_DEFAULT:
171 bench_uprobe_format__default_fprintf(name, unit, diff, stdout);
172 break;
173
174 case BENCH_FORMAT_SIMPLE:
175 printf("%" PRIu64 "\n", diff);
176 break;
177
178 default:
179 /* reaching here is something of a disaster */
180 fprintf(stderr, "Unknown format:%d\n", bench_format);
181 exit(1);
182 }
183
184 if (bench != BENCH_UPROBE__BASELINE)
185 bench_uprobe__teardown_bpf_skel();
186
187 return 0;
188}
189
190int bench_uprobe_baseline(int argc, const char **argv)
191{
192 return bench_uprobe(argc, argv, BENCH_UPROBE__BASELINE);
193}
194
195int bench_uprobe_empty(int argc, const char **argv)
196{
197 return bench_uprobe(argc, argv, BENCH_UPROBE__EMPTY);
198}
199
200int bench_uprobe_trace_printk(int argc, const char **argv)
201{
202 return bench_uprobe(argc, argv, BENCH_UPROBE__TRACE_PRINTK);
203}
204
205int bench_uprobe_empty_ret(int argc, const char **argv)
206{
207 return bench_uprobe(argc, argv, BENCH_UPROBE__EMPTY_RET);
208}
209
210int bench_uprobe_trace_printk_ret(int argc, const char **argv)
211{
212 return bench_uprobe(argc, argv, BENCH_UPROBE__TRACE_PRINTK_RET);
213}
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}