tools/perf/util/parse-events.c

   1
   2 #include "../perf.h"
   3 #include "util.h"
   4 #include "parse-options.h"
   5 #include "parse-events.h"
   6 #include "exec_cmd.h"
   7 #include "string.h"
   8
   9 extern char *strcasestr(const char *haystack, const char *needle);
  10
  11 int                                     nr_counters;
  12
  13 struct perf_counter_attr                attrs[MAX_COUNTERS];
  14
  15 struct event_symbol {
  16         u8      type;
  17         u64     config;
  18         char    *symbol;
  19         char    *alias;
  20 };
  21
  22 #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
  23 #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
  24
  25 static struct event_symbol event_symbols[] = {
  26   { CHW(CPU_CYCLES),            "cpu-cycles",           "cycles"        },
  27   { CHW(INSTRUCTIONS),          "instructions",         ""              },
  28   { CHW(CACHE_REFERENCES),      "cache-references",     ""              },
  29   { CHW(CACHE_MISSES),          "cache-misses",         ""              },
  30   { CHW(BRANCH_INSTRUCTIONS),   "branch-instructions",  "branches"      },
  31   { CHW(BRANCH_MISSES),         "branch-misses",        ""              },
  32   { CHW(BUS_CYCLES),            "bus-cycles",           ""              },
  33
  34   { CSW(CPU_CLOCK),             "cpu-clock",            ""              },
  35   { CSW(TASK_CLOCK),            "task-clock",           ""              },
  36   { CSW(PAGE_FAULTS),           "page-faults",          "faults"        },
  37   { CSW(PAGE_FAULTS_MIN),       "minor-faults",         ""              },
  38   { CSW(PAGE_FAULTS_MAJ),       "major-faults",         ""              },
  39   { CSW(CONTEXT_SWITCHES),      "context-switches",     "cs"            },
  40   { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
  41 };
  42
  43 #define __PERF_COUNTER_FIELD(config, name) \
  44         ((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
  45
  46 #define PERF_COUNTER_RAW(config)        __PERF_COUNTER_FIELD(config, RAW)
  47 #define PERF_COUNTER_CONFIG(config)     __PERF_COUNTER_FIELD(config, CONFIG)
  48 #define PERF_COUNTER_TYPE(config)       __PERF_COUNTER_FIELD(config, TYPE)
  49 #define PERF_COUNTER_ID(config)         __PERF_COUNTER_FIELD(config, EVENT)
  50
  51 static char *hw_event_names[] = {
  52         "cycles",
  53         "instructions",
  54         "cache-references",
  55         "cache-misses",
  56         "branches",
  57         "branch-misses",
  58         "bus-cycles",
  59 };
  60
  61 static char *sw_event_names[] = {
  62         "cpu-clock-msecs",
  63         "task-clock-msecs",
  64         "page-faults",
  65         "context-switches",
  66         "CPU-migrations",
  67         "minor-faults",
  68         "major-faults",
  69 };
  70
  71 #define MAX_ALIASES 8
  72
  73 static char *hw_cache[][MAX_ALIASES] = {
  74  { "L1-d$",     "l1-d",         "l1d",          "L1-data",              },
  75  { "L1-i$",     "l1-i",         "l1i",          "L1-instruction",       },
  76  { "LLC",       "L2"                                                    },
  77  { "dTLB",      "d-tlb",        "Data-TLB",                             },
  78  { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
  79  { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
  80 };
  81
  82 static char *hw_cache_op[][MAX_ALIASES] = {
  83  { "load",      "loads",        "read",                                 },
  84  { "store",     "stores",       "write",                                },
  85  { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
  86 };
  87
  88 static char *hw_cache_result[][MAX_ALIASES] = {
  89  { "refs",      "Reference",    "ops",          "access",               },
  90  { "misses",    "miss",                                                 },
  91 };
  92
  93 #define C(x)            PERF_COUNT_HW_CACHE_##x
  94 #define CACHE_READ      (1 << C(OP_READ))
  95 #define CACHE_WRITE     (1 << C(OP_WRITE))
  96 #define CACHE_PREFETCH  (1 << C(OP_PREFETCH))
  97 #define COP(x)          (1 << x)
  98
  99 /*
 100  * cache operartion stat
 101  * L1I : Read and prefetch only
 102  * ITLB and BPU : Read-only
 103  */
 104 static unsigned long hw_cache_stat[C(MAX)] = {
 105  [C(L1D)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 106  [C(L1I)]       = (CACHE_READ | CACHE_PREFETCH),
 107  [C(LL)]        = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 108  [C(DTLB)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 109  [C(ITLB)]      = (CACHE_READ),
 110  [C(BPU)]       = (CACHE_READ),
 111 };
 112
 113 static int is_cache_op_valid(u8 cache_type, u8 cache_op)
 114 {
 115         if (hw_cache_stat[cache_type] & COP(cache_op))
 116                 return 1;       /* valid */
 117         else
 118                 return 0;       /* invalid */
 119 }
 120
 121 static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
 122 {
 123         static char name[50];
 124
 125         if (cache_result) {
 126                 sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
 127                         hw_cache_op[cache_op][0],
 128                         hw_cache_result[cache_result][0]);
 129         } else {
 130                 sprintf(name, "%s-%s", hw_cache[cache_type][0],
 131                         hw_cache_op[cache_op][1]);
 132         }
 133
 134         return name;
 135 }
 136
 137 char *event_name(int counter)
 138 {
 139         u64 config = attrs[counter].config;
 140         int type = attrs[counter].type;
 141         static char buf[32];
 142
 143         if (attrs[counter].type == PERF_TYPE_RAW) {
 144                 sprintf(buf, "raw 0x%llx", config);
 145                 return buf;
 146         }
 147
 148         switch (type) {
 149         case PERF_TYPE_HARDWARE:
 150                 if (config < PERF_COUNT_HW_MAX)
 151                         return hw_event_names[config];
 152                 return "unknown-hardware";
 153
 154         case PERF_TYPE_HW_CACHE: {
 155                 u8 cache_type, cache_op, cache_result;
 156
 157                 cache_type   = (config >>  0) & 0xff;
 158                 if (cache_type > PERF_COUNT_HW_CACHE_MAX)
 159                         return "unknown-ext-hardware-cache-type";
 160
 161                 cache_op     = (config >>  8) & 0xff;
 162                 if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
 163                         return "unknown-ext-hardware-cache-op";
 164
 165                 cache_result = (config >> 16) & 0xff;
 166                 if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
 167                         return "unknown-ext-hardware-cache-result";
 168
 169                 if (!is_cache_op_valid(cache_type, cache_op))
 170                         return "invalid-cache";
 171
 172                 return event_cache_name(cache_type, cache_op, cache_result);
 173         }
 174
 175         case PERF_TYPE_SOFTWARE:
 176                 if (config < PERF_COUNT_SW_MAX)
 177                         return sw_event_names[config];
 178                 return "unknown-software";
 179
 180         default:
 181                 break;
 182         }
 183
 184         return "unknown";
 185 }
 186
 187 static int parse_aliases(const char **str, char *names[][MAX_ALIASES], int size)
 188 {
 189         int i, j;
 190         int n, longest = -1;
 191
 192         for (i = 0; i < size; i++) {
 193                 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
 194                         n = strlen(names[i][j]);
 195                         if (n > longest && !strncasecmp(*str, names[i][j], n))
 196                                 longest = n;
 197                 }
 198                 if (longest > 0) {
 199                         *str += longest;
 200                         return i;
 201                 }
 202         }
 203
 204         return -1;
 205 }
 206
 207 static int
 208 parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
 209 {
 210         const char *s = *str;
 211         int cache_type = -1, cache_op = -1, cache_result = -1;
 212
 213         cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
 214         /*
 215          * No fallback - if we cannot get a clear cache type
 216          * then bail out:
 217          */
 218         if (cache_type == -1)
 219                 return 0;
 220
 221         while ((cache_op == -1 || cache_result == -1) && *s == '-') {
 222                 ++s;
 223
 224                 if (cache_op == -1) {
 225                         cache_op = parse_aliases(&s, hw_cache_op,
 226                                                 PERF_COUNT_HW_CACHE_OP_MAX);
 227                         if (cache_op >= 0) {
 228                                 if (!is_cache_op_valid(cache_type, cache_op))
 229                                         return 0;
 230                                 continue;
 231                         }
 232                 }
 233
 234                 if (cache_result == -1) {
 235                         cache_result = parse_aliases(&s, hw_cache_result,
 236                                                 PERF_COUNT_HW_CACHE_RESULT_MAX);
 237                         if (cache_result >= 0)
 238                                 continue;
 239                 }
 240
 241                 /*
 242                  * Can't parse this as a cache op or result, so back up
 243                  * to the '-'.
 244                  */
 245                 --s;
 246                 break;
 247         }
 248
 249         /*
 250          * Fall back to reads:
 251          */
 252         if (cache_op == -1)
 253                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 254
 255         /*
 256          * Fall back to accesses:
 257          */
 258         if (cache_result == -1)
 259                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 260
 261         attr->config = cache_type | (cache_op << 8) | (cache_result << 16);
 262         attr->type = PERF_TYPE_HW_CACHE;
 263
 264         *str = s;
 265         return 1;
 266 }
 267
 268 static int check_events(const char *str, unsigned int i)
 269 {
 270         int n;
 271
 272         n = strlen(event_symbols[i].symbol);
 273         if (!strncmp(str, event_symbols[i].symbol, n))
 274                 return n;
 275
 276         n = strlen(event_symbols[i].alias);
 277         if (n)
 278                 if (!strncmp(str, event_symbols[i].alias, n))
 279                         return n;
 280         return 0;
 281 }
 282
 283 static int
 284 parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
 285 {
 286         const char *str = *strp;
 287         unsigned int i;
 288         int n;
 289
 290         for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
 291                 n = check_events(str, i);
 292                 if (n > 0) {
 293                         attr->type = event_symbols[i].type;
 294                         attr->config = event_symbols[i].config;
 295                         *strp = str + n;
 296                         return 1;
 297                 }
 298         }
 299         return 0;
 300 }
 301
 302 static int parse_raw_event(const char **strp, struct perf_counter_attr *attr)
 303 {
 304         const char *str = *strp;
 305         u64 config;
 306         int n;
 307
 308         if (*str != 'r')
 309                 return 0;
 310         n = hex2u64(str + 1, &config);
 311         if (n > 0) {
 312                 *strp = str + n + 1;
 313                 attr->type = PERF_TYPE_RAW;
 314                 attr->config = config;
 315                 return 1;
 316         }
 317         return 0;
 318 }
 319
 320 static int
 321 parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
 322 {
 323         const char *str = *strp;
 324         char *endp;
 325         unsigned long type;
 326         u64 config;
 327
 328         type = strtoul(str, &endp, 0);
 329         if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
 330                 str = endp + 1;
 331                 config = strtoul(str, &endp, 0);
 332                 if (endp > str) {
 333                         attr->type = type;
 334                         attr->config = config;
 335                         *strp = endp;
 336                         return 1;
 337                 }
 338         }
 339         return 0;
 340 }
 341
 342 static int
 343 parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
 344 {
 345         const char *str = *strp;
 346         int eu = 1, ek = 1, eh = 1;
 347
 348         if (*str++ != ':')
 349                 return 0;
 350         while (*str) {
 351                 if (*str == 'u')
 352                         eu = 0;
 353                 else if (*str == 'k')
 354                         ek = 0;
 355                 else if (*str == 'h')
 356                         eh = 0;
 357                 else
 358                         break;
 359                 ++str;
 360         }
 361         if (str >= *strp + 2) {
 362                 *strp = str;
 363                 attr->exclude_user   = eu;
 364                 attr->exclude_kernel = ek;
 365                 attr->exclude_hv     = eh;
 366                 return 1;
 367         }
 368         return 0;
 369 }
 370
 371 /*
 372  * Each event can have multiple symbolic names.
 373  * Symbolic names are (almost) exactly matched.
 374  */
 375 static int parse_event_symbols(const char **str, struct perf_counter_attr *attr)
 376 {
 377         if (!(parse_raw_event(str, attr) ||
 378               parse_numeric_event(str, attr) ||
 379               parse_symbolic_event(str, attr) ||
 380               parse_generic_hw_event(str, attr)))
 381                 return 0;
 382
 383         parse_event_modifier(str, attr);
 384
 385         return 1;
 386 }
 387
 388 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 389 {
 390         struct perf_counter_attr attr;
 391
 392         for (;;) {
 393                 if (nr_counters == MAX_COUNTERS)
 394                         return -1;
 395
 396                 memset(&attr, 0, sizeof(attr));
 397                 if (!parse_event_symbols(&str, &attr))
 398                         return -1;
 399
 400                 if (!(*str == 0 || *str == ',' || isspace(*str)))
 401                         return -1;
 402
 403                 attrs[nr_counters] = attr;
 404                 nr_counters++;
 405
 406                 if (*str == 0)
 407                         break;
 408                 if (*str == ',')
 409                         ++str;
 410                 while (isspace(*str))
 411                         ++str;
 412         }
 413
 414         return 0;
 415 }
 416
 417 static const char * const event_type_descriptors[] = {
 418         "",
 419         "Hardware event",
 420         "Software event",
 421         "Tracepoint event",
 422         "Hardware cache event",
 423 };
 424
 425 /*
 426  * Print the help text for the event symbols:
 427  */
 428 void print_events(void)
 429 {
 430         struct event_symbol *syms = event_symbols;
 431         unsigned int i, type, op, prev_type = -1;
 432         char name[40];
 433
 434         fprintf(stderr, "\n");
 435         fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
 436
 437         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
 438                 type = syms->type + 1;
 439                 if (type > ARRAY_SIZE(event_type_descriptors))
 440                         type = 0;
 441
 442                 if (type != prev_type)
 443                         fprintf(stderr, "\n");
 444
 445                 if (strlen(syms->alias))
 446                         sprintf(name, "%s OR %s", syms->symbol, syms->alias);
 447                 else
 448                         strcpy(name, syms->symbol);
 449                 fprintf(stderr, "  %-40s [%s]\n", name,
 450                         event_type_descriptors[type]);
 451
 452                 prev_type = type;
 453         }
 454
 455         fprintf(stderr, "\n");
 456         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
 457                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
 458                         /* skip invalid cache type */
 459                         if (!is_cache_op_valid(type, op))
 460                                 continue;
 461
 462                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
 463                                 fprintf(stderr, "  %-40s [%s]\n",
 464                                         event_cache_name(type, op, i),
 465                                         event_type_descriptors[4]);
 466                         }
 467                 }
 468         }
 469
 470         fprintf(stderr, "\n");
 471         fprintf(stderr, "  %-40s [raw hardware event descriptor]\n",
 472                 "rNNN");
 473         fprintf(stderr, "\n");
 474
 475         exit(129);
 476 }