0001
0002 #include <inttypes.h>
0003 #include <stdio.h>
0004 #include <stdlib.h>
0005 #include <limits.h>
0006 #include "bench.h"
0007 #include "../util/debug.h"
0008 #include "../util/stat.h"
0009 #include "../util/evlist.h"
0010 #include "../util/evsel.h"
0011 #include "../util/strbuf.h"
0012 #include "../util/record.h"
0013 #include "../util/parse-events.h"
0014 #include "internal/threadmap.h"
0015 #include "internal/cpumap.h"
0016 #include <linux/perf_event.h>
0017 #include <linux/kernel.h>
0018 #include <linux/time64.h>
0019 #include <linux/string.h>
0020 #include <subcmd/parse-options.h>
0021
0022 #define MMAP_FLUSH_DEFAULT 1
0023
0024 static int iterations = 100;
0025 static int nr_events = 1;
0026 static const char *event_string = "dummy";
0027
0028 static inline u64 timeval2usec(struct timeval *tv)
0029 {
0030 return tv->tv_sec * USEC_PER_SEC + tv->tv_usec;
0031 }
0032
0033 static struct record_opts opts = {
0034 .sample_time = true,
0035 .mmap_pages = UINT_MAX,
0036 .user_freq = UINT_MAX,
0037 .user_interval = ULLONG_MAX,
0038 .freq = 4000,
0039 .target = {
0040 .uses_mmap = true,
0041 .default_per_cpu = true,
0042 },
0043 .mmap_flush = MMAP_FLUSH_DEFAULT,
0044 .nr_threads_synthesize = 1,
0045 .ctl_fd = -1,
0046 .ctl_fd_ack = -1,
0047 };
0048
0049 static const struct option options[] = {
0050 OPT_STRING('e', "event", &event_string, "event", "event selector. use 'perf list' to list available events"),
0051 OPT_INTEGER('n', "nr-events", &nr_events,
0052 "number of dummy events to create (default 1). If used with -e, it clones those events n times (1 = no change)"),
0053 OPT_INTEGER('i', "iterations", &iterations, "Number of iterations used to compute average (default=100)"),
0054 OPT_BOOLEAN('a', "all-cpus", &opts.target.system_wide, "system-wide collection from all CPUs"),
0055 OPT_STRING('C', "cpu", &opts.target.cpu_list, "cpu", "list of cpus where to open events"),
0056 OPT_STRING('p', "pid", &opts.target.pid, "pid", "record events on existing process id"),
0057 OPT_STRING('t', "tid", &opts.target.tid, "tid", "record events on existing thread id"),
0058 OPT_STRING('u', "uid", &opts.target.uid_str, "user", "user to profile"),
0059 OPT_BOOLEAN(0, "per-thread", &opts.target.per_thread, "use per-thread mmaps"),
0060 OPT_END()
0061 };
0062
0063 static const char *const bench_usage[] = {
0064 "perf bench internals evlist-open-close <options>",
0065 NULL
0066 };
0067
0068 static int evlist__count_evsel_fds(struct evlist *evlist)
0069 {
0070 struct evsel *evsel;
0071 int cnt = 0;
0072
0073 evlist__for_each_entry(evlist, evsel)
0074 cnt += evsel->core.threads->nr * perf_cpu_map__nr(evsel->core.cpus);
0075
0076 return cnt;
0077 }
0078
0079 static struct evlist *bench__create_evlist(char *evstr)
0080 {
0081 struct parse_events_error err;
0082 struct evlist *evlist = evlist__new();
0083 int ret;
0084
0085 if (!evlist) {
0086 pr_err("Not enough memory to create evlist\n");
0087 return NULL;
0088 }
0089
0090 parse_events_error__init(&err);
0091 ret = parse_events(evlist, evstr, &err);
0092 if (ret) {
0093 parse_events_error__print(&err, evstr);
0094 parse_events_error__exit(&err);
0095 pr_err("Run 'perf list' for a list of valid events\n");
0096 ret = 1;
0097 goto out_delete_evlist;
0098 }
0099 parse_events_error__exit(&err);
0100 ret = evlist__create_maps(evlist, &opts.target);
0101 if (ret < 0) {
0102 pr_err("Not enough memory to create thread/cpu maps\n");
0103 goto out_delete_evlist;
0104 }
0105
0106 evlist__config(evlist, &opts, NULL);
0107
0108 return evlist;
0109
0110 out_delete_evlist:
0111 evlist__delete(evlist);
0112 return NULL;
0113 }
0114
0115 static int bench__do_evlist_open_close(struct evlist *evlist)
0116 {
0117 char sbuf[STRERR_BUFSIZE];
0118 int err = evlist__open(evlist);
0119
0120 if (err < 0) {
0121 pr_err("evlist__open: %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
0122 return err;
0123 }
0124
0125 err = evlist__mmap(evlist, opts.mmap_pages);
0126 if (err < 0) {
0127 pr_err("evlist__mmap: %s\n", str_error_r(errno, sbuf, sizeof(sbuf)));
0128 return err;
0129 }
0130
0131 evlist__enable(evlist);
0132 evlist__disable(evlist);
0133 evlist__munmap(evlist);
0134 evlist__close(evlist);
0135
0136 return 0;
0137 }
0138
0139 static int bench_evlist_open_close__run(char *evstr)
0140 {
0141
0142 struct evlist *evlist = bench__create_evlist(evstr);
0143 double time_average, time_stddev;
0144 struct timeval start, end, diff;
0145 struct stats time_stats;
0146 u64 runtime_us;
0147 int i, err;
0148
0149 if (!evlist)
0150 return -ENOMEM;
0151
0152 init_stats(&time_stats);
0153
0154 printf(" Number of cpus:\t%d\n", perf_cpu_map__nr(evlist->core.user_requested_cpus));
0155 printf(" Number of threads:\t%d\n", evlist->core.threads->nr);
0156 printf(" Number of events:\t%d (%d fds)\n",
0157 evlist->core.nr_entries, evlist__count_evsel_fds(evlist));
0158 printf(" Number of iterations:\t%d\n", iterations);
0159
0160 evlist__delete(evlist);
0161
0162 for (i = 0; i < iterations; i++) {
0163 pr_debug("Started iteration %d\n", i);
0164 evlist = bench__create_evlist(evstr);
0165 if (!evlist)
0166 return -ENOMEM;
0167
0168 gettimeofday(&start, NULL);
0169 err = bench__do_evlist_open_close(evlist);
0170 if (err) {
0171 evlist__delete(evlist);
0172 return err;
0173 }
0174
0175 gettimeofday(&end, NULL);
0176 timersub(&end, &start, &diff);
0177 runtime_us = timeval2usec(&diff);
0178 update_stats(&time_stats, runtime_us);
0179
0180 evlist__delete(evlist);
0181 pr_debug("Iteration %d took:\t%" PRIu64 "us\n", i, runtime_us);
0182 }
0183
0184 time_average = avg_stats(&time_stats);
0185 time_stddev = stddev_stats(&time_stats);
0186 printf(" Average open-close took: %.3f usec (+- %.3f usec)\n", time_average, time_stddev);
0187
0188 return 0;
0189 }
0190
0191 static char *bench__repeat_event_string(const char *evstr, int n)
0192 {
0193 char sbuf[STRERR_BUFSIZE];
0194 struct strbuf buf;
0195 int i, str_size = strlen(evstr),
0196 final_size = str_size * n + n,
0197 err = strbuf_init(&buf, final_size);
0198
0199 if (err) {
0200 pr_err("strbuf_init: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
0201 goto out_error;
0202 }
0203
0204 for (i = 0; i < n; i++) {
0205 err = strbuf_add(&buf, evstr, str_size);
0206 if (err) {
0207 pr_err("strbuf_add: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
0208 goto out_error;
0209 }
0210
0211 err = strbuf_addch(&buf, i == n-1 ? '\0' : ',');
0212 if (err) {
0213 pr_err("strbuf_addch: %s\n", str_error_r(err, sbuf, sizeof(sbuf)));
0214 goto out_error;
0215 }
0216 }
0217
0218 return strbuf_detach(&buf, NULL);
0219
0220 out_error:
0221 strbuf_release(&buf);
0222 return NULL;
0223 }
0224
0225
0226 int bench_evlist_open_close(int argc, const char **argv)
0227 {
0228 char *evstr, errbuf[BUFSIZ];
0229 int err;
0230
0231 argc = parse_options(argc, argv, options, bench_usage, 0);
0232 if (argc) {
0233 usage_with_options(bench_usage, options);
0234 exit(EXIT_FAILURE);
0235 }
0236
0237 err = target__validate(&opts.target);
0238 if (err) {
0239 target__strerror(&opts.target, err, errbuf, sizeof(errbuf));
0240 pr_err("%s\n", errbuf);
0241 goto out;
0242 }
0243
0244 err = target__parse_uid(&opts.target);
0245 if (err) {
0246 target__strerror(&opts.target, err, errbuf, sizeof(errbuf));
0247 pr_err("%s", errbuf);
0248 goto out;
0249 }
0250
0251
0252 opts.ignore_missing_thread = opts.target.uid != UINT_MAX || opts.target.pid;
0253
0254 evstr = bench__repeat_event_string(event_string, nr_events);
0255 if (!evstr) {
0256 err = -ENOMEM;
0257 goto out;
0258 }
0259
0260 err = bench_evlist_open_close__run(evstr);
0261
0262 free(evstr);
0263 out:
0264 return err;
0265 }
