1
2#include <inttypes.h>
3#include <stdio.h>
4#include <stdlib.h>
5#include <limits.h>
6#include "bench.h"
7#include "../util/debug.h"
8#include "../util/stat.h"
9#include "../util/evlist.h"
10#include "../util/evsel.h"
11#include "../util/strbuf.h"
12#include "../util/record.h"
13#include "../util/parse-events.h"
14#include "internal/threadmap.h"
15#include "internal/cpumap.h"
16#include <linux/perf_event.h>
17#include <linux/kernel.h>
18#include <linux/time64.h>
19#include <linux/string.h>
20#include <subcmd/parse-options.h>
21
22#define MMAP_FLUSH_DEFAULT 1
23
24static int iterations = 100;
25static int nr_events = 1;
26static const char *event_string = "dummy";
27
28static struct record_opts opts = {
29 .sample_time = true,
30 .mmap_pages = UINT_MAX,
31 .user_freq = UINT_MAX,
32 .user_interval = ULLONG_MAX,
33 .freq = 4000,
34 .target = {
35 .uses_mmap = true,
36 .default_per_cpu = true,
37 },
38 .mmap_flush = MMAP_FLUSH_DEFAULT,
39 .nr_threads_synthesize = 1,
40 .ctl_fd = -1,
41 .ctl_fd_ack = -1,
42};
43
44static const struct option options[] = {
45 OPT_STRING('e', "event", &event_string, "event", "event selector. use 'perf list' to list available events"),
46 OPT_INTEGER('n', "nr-events", &nr_events,
47 "number of dummy events to create (default 1). If used with -e, it clones those events n times (1 = no change)"),
48 OPT_INTEGER('i', "iterations", &iterations, "Number of iterations used to compute average (default=100)"),
49 OPT_BOOLEAN('a', "all-cpus", &opts.target.system_wide, "system-wide collection from all CPUs"),
50 OPT_STRING('C', "cpu", &opts.target.cpu_list, "cpu", "list of cpus where to open events"),
51 OPT_STRING('p', "pid", &opts.target.pid, "pid", "record events on existing process id"),
52 OPT_STRING('t', "tid", &opts.target.tid, "tid", "record events on existing thread id"),
53 OPT_STRING('u', "uid", &opts.target.uid_str, "user", "user to profile"),
54 OPT_BOOLEAN(0, "per-thread", &opts.target.per_thread, "use per-thread mmaps"),
55 OPT_END()
56};
57
58static const char *const bench_usage[] = {
59 "perf bench internals evlist-open-close <options>",
60 NULL
61};
62
63static int evlist__count_evsel_fds(struct evlist *evlist)
64{
65 struct evsel *evsel;
66 int cnt = 0;
67
68 evlist__for_each_entry(evlist, evsel)
69 cnt += evsel->core.threads->nr * evsel->core.cpus->nr;
70
71 return cnt;
72}
73
74static struct evlist *bench__create_evlist(char *evstr)
75{
76 struct parse_events_error err = { .idx = 0, };
77 struct evlist *evlist = evlist__new();
78 int ret;
79
80 if (!evlist) {
81 pr_err("Not enough memory to create evlist\n");
82 return NULL;
83 }
84
85 ret = parse_events(evlist, evstr, &err);
86 if (ret) {
87 parse_events_print_error(&err, evstr);
88 pr_err("Run 'perf list' for a list of valid events\n");
89 ret = 1;
90 goto out_delete_evlist;
91 }
92
93 ret = evlist__create_maps(evlist, &opts.target);
94 if (ret < 0) {
95 pr_err("Not enough memory to create thread/cpu maps\n");
96 goto out_delete_evlist;
97 }
98
99 evlist__config(evlist, &opts, NULL);
100
101 return evlist;
102
103out_delete_evlist:
104 evlist__delete(evlist);
105 return NULL;
106}
107
108static int bench__do_evlist_open_close(struct evlist *evlist)
109{
110 char sbuf[STRERR_BUFSIZE];
111 int err = evlist__open(evlist);
112
113 if (err < 0) {
114 pr_err("evlist__open: %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
115 return err;
116 }
117
118 err = evlist__mmap(evlist, opts.mmap_pages);
119 if (err < 0) {
120 pr_err("evlist__mmap: %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
121 return err;
122 }
123
124 evlist__enable(evlist);
125 evlist__disable(evlist);
126 evlist__munmap(evlist);
127 evlist__close(evlist);
128
129 return 0;
130}
131
132static int bench_evlist_open_close__run(char *evstr)
133{
134
135 struct evlist *evlist = bench__create_evlist(evstr);
136 double time_average, time_stddev;
137 struct timeval start, end, diff;
138 struct stats time_stats;
139 u64 runtime_us;
140 int i, err;
141
142 if (!evlist)
143 return -ENOMEM;
144
145 init_stats(&time_stats);
146
147 printf(" Number of cpus:\t%d\n", evlist->core.cpus->nr);
148 printf(" Number of threads:\t%d\n", evlist->core.threads->nr);
149 printf(" Number of events:\t%d (%d fds)\n",
150 evlist->core.nr_entries, evlist__count_evsel_fds(evlist));
151 printf(" Number of iterations:\t%d\n", iterations);
152
153 evlist__delete(evlist);
154
155 for (i = 0; i < iterations; i++) {
156 pr_debug("Started iteration %d\n", i);
157 evlist = bench__create_evlist(evstr);
158 if (!evlist)
159 return -ENOMEM;
160
161 gettimeofday(&start, NULL);
162 err = bench__do_evlist_open_close(evlist);
163 if (err) {
164 evlist__delete(evlist);
165 return err;
166 }
167
168 gettimeofday(&end, NULL);
169 timersub(&end, &start, &diff);
170 runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
171 update_stats(&time_stats, runtime_us);
172
173 evlist__delete(evlist);
174 pr_debug("Iteration %d took:\t%" PRIu64 "us\n", i, runtime_us);
175 }
176
177 time_average = avg_stats(&time_stats);
178 time_stddev = stddev_stats(&time_stats);
179 printf(" Average open-close took: %.3f usec (+- %.3f usec)\n", time_average, time_stddev);
180
181 return 0;
182}
183
184static char *bench__repeat_event_string(const char *evstr, int n)
185{
186 char sbuf[STRERR_BUFSIZE];
187 struct strbuf buf;
188 int i, str_size = strlen(evstr),
189 final_size = str_size * n + n,
190 err = strbuf_init(&buf, final_size);
191
192 if (err) {
193 pr_err("strbuf_init: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
194 goto out_error;
195 }
196
197 for (i = 0; i < n; i++) {
198 err = strbuf_add(&buf, evstr, str_size);
199 if (err) {
200 pr_err("strbuf_add: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
201 goto out_error;
202 }
203
204 err = strbuf_addch(&buf, i == n-1 ? '\0' : ',');
205 if (err) {
206 pr_err("strbuf_addch: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
207 goto out_error;
208 }
209 }
210
211 return strbuf_detach(&buf, NULL);
212
213out_error:
214 strbuf_release(&buf);
215 return NULL;
216}
217
218
219int bench_evlist_open_close(int argc, const char **argv)
220{
221 char *evstr, errbuf[BUFSIZ];
222 int err;
223
224 argc = parse_options(argc, argv, options, bench_usage, 0);
225 if (argc) {
226 usage_with_options(bench_usage, options);
227 exit(EXIT_FAILURE);
228 }
229
230 err = target__validate(&opts.target);
231 if (err) {
232 target__strerror(&opts.target, err, errbuf, sizeof(errbuf));
233 pr_err("%s\n", errbuf);
234 goto out;
235 }
236
237 err = target__parse_uid(&opts.target);
238 if (err) {
239 target__strerror(&opts.target, err, errbuf, sizeof(errbuf));
240 pr_err("%s", errbuf);
241 goto out;
242 }
243
244
245 opts.ignore_missing_thread = opts.target.uid != UINT_MAX || opts.target.pid;
246
247 evstr = bench__repeat_event_string(event_string, nr_events);
248 if (!evstr) {
249 err = -ENOMEM;
250 goto out;
251 }
252
253 err = bench_evlist_open_close__run(evstr);
254
255 free(evstr);
256out:
257 return err;
258}
259
