1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Benchmark synthesis of perf events such as at the start of a 'perf
4 * record'. Synthesis is done on the current process and the 'dummy' event
5 * handlers are invoked that support dump_trace but otherwise do nothing.
6 *
7 * Copyright 2019 Google LLC.
8 */
9 #include <stdio.h>
10 #include "bench.h"
11 #include "../util/debug.h"
12 #include "../util/session.h"
13 #include "../util/stat.h"
14 #include "../util/synthetic-events.h"
15 #include "../util/target.h"
16 #include "../util/thread_map.h"
17 #include "../util/tool.h"
18 #include "../util/util.h"
19 #include <linux/atomic.h>
20 #include <linux/err.h>
21 #include <linux/time64.h>
22 #include <subcmd/parse-options.h>
23
24 static unsigned int min_threads = 1;
25 static unsigned int max_threads = UINT_MAX;
26 static unsigned int single_iterations = 10000;
27 static unsigned int multi_iterations = 10;
28 static bool run_st;
29 static bool run_mt;
30
31 static const struct option options[] = {
32 OPT_BOOLEAN('s', "st", &run_st, "Run single threaded benchmark"),
33 OPT_BOOLEAN('t', "mt", &run_mt, "Run multi-threaded benchmark"),
34 OPT_UINTEGER('m', "min-threads", &min_threads,
35 "Minimum number of threads in multithreaded bench"),
36 OPT_UINTEGER('M', "max-threads", &max_threads,
37 "Maximum number of threads in multithreaded bench"),
38 OPT_UINTEGER('i', "single-iterations", &single_iterations,
39 "Number of iterations used to compute single-threaded average"),
40 OPT_UINTEGER('I', "multi-iterations", &multi_iterations,
41 "Number of iterations used to compute multi-threaded average"),
42 OPT_END()
43 };
44
45 static const char *const bench_usage[] = {
46 "perf bench internals synthesize <options>",
47 NULL
48 };
49
50 static atomic_t event_count;
51
process_synthesized_event(const struct perf_tool * tool __maybe_unused,union perf_event * event __maybe_unused,struct perf_sample * sample __maybe_unused,struct machine * machine __maybe_unused)52 static int process_synthesized_event(const struct perf_tool *tool __maybe_unused,
53 union perf_event *event __maybe_unused,
54 struct perf_sample *sample __maybe_unused,
55 struct machine *machine __maybe_unused)
56 {
57 atomic_inc(&event_count);
58 return 0;
59 }
60
do_run_single_threaded(struct perf_session * session,struct perf_thread_map * threads,struct target * target,bool data_mmap)61 static int do_run_single_threaded(struct perf_session *session,
62 struct perf_thread_map *threads,
63 struct target *target, bool data_mmap)
64 {
65 const unsigned int nr_threads_synthesize = 1;
66 struct timeval start, end, diff;
67 u64 runtime_us;
68 unsigned int i;
69 double time_average, time_stddev, event_average, event_stddev;
70 int err;
71 struct stats time_stats, event_stats;
72
73 init_stats(&time_stats);
74 init_stats(&event_stats);
75
76 for (i = 0; i < single_iterations; i++) {
77 atomic_set(&event_count, 0);
78 gettimeofday(&start, NULL);
79 err = __machine__synthesize_threads(&session->machines.host,
80 NULL,
81 target, threads,
82 process_synthesized_event,
83 true, data_mmap,
84 nr_threads_synthesize);
85 if (err)
86 return err;
87
88 gettimeofday(&end, NULL);
89 timersub(&end, &start, &diff);
90 runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
91 update_stats(&time_stats, runtime_us);
92 update_stats(&event_stats, atomic_read(&event_count));
93 }
94
95 time_average = avg_stats(&time_stats);
96 time_stddev = stddev_stats(&time_stats);
97 printf(" Average %ssynthesis took: %.3f usec (+- %.3f usec)\n",
98 data_mmap ? "data " : "", time_average, time_stddev);
99
100 event_average = avg_stats(&event_stats);
101 event_stddev = stddev_stats(&event_stats);
102 printf(" Average num. events: %.3f (+- %.3f)\n",
103 event_average, event_stddev);
104
105 printf(" Average time per event %.3f usec\n",
106 time_average / event_average);
107 return 0;
108 }
109
run_single_threaded(void)110 static int run_single_threaded(void)
111 {
112 struct perf_session *session;
113 struct target target = {
114 .pid = "self",
115 };
116 struct perf_thread_map *threads;
117 struct perf_env host_env;
118 int err;
119
120 perf_set_singlethreaded();
121 perf_env__init(&host_env);
122 session = __perf_session__new(/*data=*/NULL, /*tool=*/NULL,
123 /*trace_event_repipe=*/false, &host_env);
124 if (IS_ERR(session)) {
125 pr_err("Session creation failed.\n");
126 perf_env__exit(&host_env);
127 return PTR_ERR(session);
128 }
129 threads = thread_map__new_by_pid(getpid());
130 if (!threads) {
131 pr_err("Thread map creation failed.\n");
132 err = -ENOMEM;
133 goto err_out;
134 }
135
136 puts(
137 "Computing performance of single threaded perf event synthesis by\n"
138 "synthesizing events on the perf process itself:");
139
140 err = do_run_single_threaded(session, threads, &target, false);
141 if (err)
142 goto err_out;
143
144 err = do_run_single_threaded(session, threads, &target, true);
145
146 err_out:
147 if (threads)
148 perf_thread_map__put(threads);
149
150 perf_session__delete(session);
151 perf_env__exit(&host_env);
152 return err;
153 }
154
do_run_multi_threaded(struct target * target,unsigned int nr_threads_synthesize)155 static int do_run_multi_threaded(struct target *target,
156 unsigned int nr_threads_synthesize)
157 {
158 struct timeval start, end, diff;
159 u64 runtime_us;
160 unsigned int i;
161 double time_average, time_stddev, event_average, event_stddev;
162 int err = 0;
163 struct stats time_stats, event_stats;
164 struct perf_session *session;
165 struct perf_env host_env;
166
167 perf_env__init(&host_env);
168 init_stats(&time_stats);
169 init_stats(&event_stats);
170 for (i = 0; i < multi_iterations; i++) {
171 session = __perf_session__new(/*data=*/NULL, /*tool=*/NULL,
172 /*trace_event_repipe=*/false, &host_env);
173 if (IS_ERR(session)) {
174 err = PTR_ERR(session);
175 goto err_out;
176 }
177 atomic_set(&event_count, 0);
178 gettimeofday(&start, NULL);
179 err = __machine__synthesize_threads(&session->machines.host,
180 NULL,
181 target, NULL,
182 process_synthesized_event,
183 true, false,
184 nr_threads_synthesize);
185 if (err) {
186 perf_session__delete(session);
187 goto err_out;
188 }
189
190 gettimeofday(&end, NULL);
191 timersub(&end, &start, &diff);
192 runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
193 update_stats(&time_stats, runtime_us);
194 update_stats(&event_stats, atomic_read(&event_count));
195 perf_session__delete(session);
196 }
197
198 time_average = avg_stats(&time_stats);
199 time_stddev = stddev_stats(&time_stats);
200 printf(" Average synthesis took: %.3f usec (+- %.3f usec)\n",
201 time_average, time_stddev);
202
203 event_average = avg_stats(&event_stats);
204 event_stddev = stddev_stats(&event_stats);
205 printf(" Average num. events: %.3f (+- %.3f)\n",
206 event_average, event_stddev);
207
208 printf(" Average time per event %.3f usec\n",
209 time_average / event_average);
210 err_out:
211 perf_env__exit(&host_env);
212 return err;
213 }
214
run_multi_threaded(void)215 static int run_multi_threaded(void)
216 {
217 struct target target = {
218 .cpu_list = "0"
219 };
220 unsigned int nr_threads_synthesize;
221 int err;
222
223 if (max_threads == UINT_MAX)
224 max_threads = sysconf(_SC_NPROCESSORS_ONLN);
225
226 puts(
227 "Computing performance of multi threaded perf event synthesis by\n"
228 "synthesizing events on CPU 0:");
229
230 for (nr_threads_synthesize = min_threads;
231 nr_threads_synthesize <= max_threads;
232 nr_threads_synthesize++) {
233 if (nr_threads_synthesize == 1)
234 perf_set_singlethreaded();
235 else
236 perf_set_multithreaded();
237
238 printf(" Number of synthesis threads: %u\n",
239 nr_threads_synthesize);
240
241 err = do_run_multi_threaded(&target, nr_threads_synthesize);
242 if (err)
243 return err;
244 }
245 perf_set_singlethreaded();
246 return 0;
247 }
248
bench_synthesize(int argc,const char ** argv)249 int bench_synthesize(int argc, const char **argv)
250 {
251 int err = 0;
252
253 argc = parse_options(argc, argv, options, bench_usage, 0);
254 if (argc) {
255 usage_with_options(bench_usage, options);
256 exit(EXIT_FAILURE);
257 }
258
259 /*
260 * If neither single threaded or multi-threaded are specified, default
261 * to running just single threaded.
262 */
263 if (!run_st && !run_mt)
264 run_st = true;
265
266 if (run_st)
267 err = run_single_threaded();
268
269 if (!err && run_mt)
270 err = run_multi_threaded();
271
272 return err;
273 }
274