tools/perf/bench/evlist-open-close.c

   1 // SPDX-License-Identifier: GPL-2.0
   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
  24 static int iterations = 100;
  25 static int nr_events = 1;
  26 static const char *event_string = "dummy";
  27
  28 static 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
  44 static 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
  58 static const char *const bench_usage[] = {
  59         "perf bench internals evlist-open-close <options>",
  60         NULL
  61 };
  62
  63 static 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
  74 static 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
 103 out_delete_evlist:
 104         evlist__delete(evlist);
 105         return NULL;
 106 }
 107
 108 static 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
 132 static int bench_evlist_open_close__run(char *evstr)
 133 {
 134         // used to print statistics only
 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
 184 static 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
 213 out_error:
 214         strbuf_release(&buf);
 215         return NULL;
 216 }
 217
 218
 219 int 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         /* Enable ignoring missing threads when -u/-p option is defined. */
 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);
 256 out:
 257         return err;
 258 }