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 26 static int loops = LOOPS_DEFAULT; 27 28 enum 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 36 static const struct option options[] = { 37 OPT_INTEGER('l', "loop", &loops, "Specify number of loops"), 38 OPT_END() 39 }; 40 41 static 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 61 struct bench_uprobe_bpf *skel; 62 63 static 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; 94 cleanup: 95 bench_uprobe_bpf__destroy(skel); 96 skel = NULL; 97 return err; 98 } 99 100 static void bench_uprobe__teardown_bpf_skel(void) 101 { 102 if (skel) { 103 bench_uprobe_bpf__destroy(skel); 104 skel = NULL; 105 } 106 } 107 #else 108 static int bench_uprobe__setup_bpf_skel(enum bench_uprobe bench __maybe_unused) { return 0; } 109 static void bench_uprobe__teardown_bpf_skel(void) {}; 110 #endif 111 112 static 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 146 static 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 190 int bench_uprobe_baseline(int argc, const char **argv) 191 { 192 return bench_uprobe(argc, argv, BENCH_UPROBE__BASELINE); 193 } 194 195 int bench_uprobe_empty(int argc, const char **argv) 196 { 197 return bench_uprobe(argc, argv, BENCH_UPROBE__EMPTY); 198 } 199 200 int bench_uprobe_trace_printk(int argc, const char **argv) 201 { 202 return bench_uprobe(argc, argv, BENCH_UPROBE__TRACE_PRINTK); 203 } 204 205 int bench_uprobe_empty_ret(int argc, const char **argv) 206 { 207 return bench_uprobe(argc, argv, BENCH_UPROBE__EMPTY_RET); 208 } 209 210 int bench_uprobe_trace_printk_ret(int argc, const char **argv) 211 { 212 return bench_uprobe(argc, argv, BENCH_UPROBE__TRACE_PRINTK_RET); 213 } 214