tools/perf/util/expr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdbool.h>
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "metricgroup.h"
   8 #include "debug.h"
   9 #include "evlist.h"
  10 #include "expr.h"
  11 #include "smt.h"
  12 #include "tool_pmu.h"
  13 #include <util/expr-bison.h>
  14 #include <util/expr-flex.h>
  15 #include "util/hashmap.h"
  16 #include "util/header.h"
  17 #include "util/pmu.h"
  18 #include <perf/cpumap.h>
  19 #include <linux/err.h>
  20 #include <linux/kernel.h>
  21 #include <linux/zalloc.h>
  22 #include <ctype.h>
  23 #include <math.h>
  24
  25 struct expr_id_data {
  26         union {
  27                 struct {
  28                         double val;
  29                         int source_count;
  30                 } val;
  31                 struct {
  32                         double val;
  33                         const char *metric_name;
  34                         const char *metric_expr;
  35                 } ref;
  36         };
  37
  38         enum {
  39                 /* Holding a double value. */
  40                 EXPR_ID_DATA__VALUE,
  41                 /* Reference to another metric. */
  42                 EXPR_ID_DATA__REF,
  43                 /* A reference but the value has been computed. */
  44                 EXPR_ID_DATA__REF_VALUE,
  45         } kind;
  46 };
  47
  48 static size_t key_hash(long key, void *ctx __maybe_unused)
  49 {
  50         const char *str = (const char *)key;
  51         size_t hash = 0;
  52
  53         while (*str != '\0') {
  54                 hash *= 31;
  55                 hash += *str;
  56                 str++;
  57         }
  58         return hash;
  59 }
  60
  61 static bool key_equal(long key1, long key2, void *ctx __maybe_unused)
  62 {
  63         return !strcmp((const char *)key1, (const char *)key2);
  64 }
  65
  66 struct hashmap *ids__new(void)
  67 {
  68         struct hashmap *hash;
  69
  70         hash = hashmap__new(key_hash, key_equal, NULL);
  71         if (IS_ERR(hash))
  72                 return NULL;
  73         return hash;
  74 }
  75
  76 void ids__free(struct hashmap *ids)
  77 {
  78         struct hashmap_entry *cur;
  79         size_t bkt;
  80
  81         if (ids == NULL)
  82                 return;
  83
  84         hashmap__for_each_entry(ids, cur, bkt) {
  85                 zfree(&cur->pkey);
  86                 zfree(&cur->pvalue);
  87         }
  88
  89         hashmap__free(ids);
  90 }
  91
  92 int ids__insert(struct hashmap *ids, const char *id)
  93 {
  94         struct expr_id_data *data_ptr = NULL, *old_data = NULL;
  95         char *old_key = NULL;
  96         int ret;
  97
  98         ret = hashmap__set(ids, id, data_ptr, &old_key, &old_data);
  99         if (ret)
 100                 free(data_ptr);
 101         free(old_key);
 102         free(old_data);
 103         return ret;
 104 }
 105
 106 struct hashmap *ids__union(struct hashmap *ids1, struct hashmap *ids2)
 107 {
 108         size_t bkt;
 109         struct hashmap_entry *cur;
 110         int ret;
 111         struct expr_id_data *old_data = NULL;
 112         char *old_key = NULL;
 113
 114         if (!ids1)
 115                 return ids2;
 116
 117         if (!ids2)
 118                 return ids1;
 119
 120         if (hashmap__size(ids1) <  hashmap__size(ids2)) {
 121                 struct hashmap *tmp = ids1;
 122
 123                 ids1 = ids2;
 124                 ids2 = tmp;
 125         }
 126         hashmap__for_each_entry(ids2, cur, bkt) {
 127                 ret = hashmap__set(ids1, cur->key, cur->value, &old_key, &old_data);
 128                 free(old_key);
 129                 free(old_data);
 130
 131                 if (ret) {
 132                         hashmap__free(ids1);
 133                         hashmap__free(ids2);
 134                         return NULL;
 135                 }
 136         }
 137         hashmap__free(ids2);
 138         return ids1;
 139 }
 140
 141 /* Caller must make sure id is allocated */
 142 int expr__add_id(struct expr_parse_ctx *ctx, const char *id)
 143 {
 144         return ids__insert(ctx->ids, id);
 145 }
 146
 147 /* Caller must make sure id is allocated */
 148 int expr__add_id_val(struct expr_parse_ctx *ctx, const char *id, double val)
 149 {
 150         return expr__add_id_val_source_count(ctx, id, val, /*source_count=*/1);
 151 }
 152
 153 /* Caller must make sure id is allocated */
 154 int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
 155                                   double val, int source_count)
 156 {
 157         struct expr_id_data *data_ptr = NULL, *old_data = NULL;
 158         char *old_key = NULL;
 159         int ret;
 160
 161         data_ptr = malloc(sizeof(*data_ptr));
 162         if (!data_ptr)
 163                 return -ENOMEM;
 164         data_ptr->val.val = val;
 165         data_ptr->val.source_count = source_count;
 166         data_ptr->kind = EXPR_ID_DATA__VALUE;
 167
 168         ret = hashmap__set(ctx->ids, id, data_ptr, &old_key, &old_data);
 169         if (ret)
 170                 free(data_ptr);
 171         free(old_key);
 172         free(old_data);
 173         return ret;
 174 }
 175
 176 int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref)
 177 {
 178         struct expr_id_data *data_ptr = NULL, *old_data = NULL;
 179         char *old_key = NULL;
 180         char *name;
 181         int ret;
 182
 183         data_ptr = zalloc(sizeof(*data_ptr));
 184         if (!data_ptr)
 185                 return -ENOMEM;
 186
 187         name = strdup(ref->metric_name);
 188         if (!name) {
 189                 free(data_ptr);
 190                 return -ENOMEM;
 191         }
 192
 193         /*
 194          * Intentionally passing just const char pointers,
 195          * originally from 'struct pmu_event' object.
 196          * We don't need to change them, so there's no
 197          * need to create our own copy.
 198          */
 199         data_ptr->ref.metric_name = ref->metric_name;
 200         data_ptr->ref.metric_expr = ref->metric_expr;
 201         data_ptr->kind = EXPR_ID_DATA__REF;
 202
 203         ret = hashmap__set(ctx->ids, name, data_ptr, &old_key, &old_data);
 204         if (ret)
 205                 free(data_ptr);
 206
 207         pr_debug2("adding ref metric %s: %s\n",
 208                   ref->metric_name, ref->metric_expr);
 209
 210         free(old_key);
 211         free(old_data);
 212         return ret;
 213 }
 214
 215 int expr__get_id(struct expr_parse_ctx *ctx, const char *id,
 216                  struct expr_id_data **data)
 217 {
 218         return hashmap__find(ctx->ids, id, data) ? 0 : -1;
 219 }
 220
 221 bool expr__subset_of_ids(struct expr_parse_ctx *haystack,
 222                          struct expr_parse_ctx *needles)
 223 {
 224         struct hashmap_entry *cur;
 225         size_t bkt;
 226         struct expr_id_data *data;
 227
 228         hashmap__for_each_entry(needles->ids, cur, bkt) {
 229                 if (expr__get_id(haystack, cur->pkey, &data))
 230                         return false;
 231         }
 232         return true;
 233 }
 234
 235
 236 int expr__resolve_id(struct expr_parse_ctx *ctx, const char *id,
 237                      struct expr_id_data **datap)
 238 {
 239         struct expr_id_data *data;
 240
 241         if (expr__get_id(ctx, id, datap) || !*datap) {
 242                 pr_debug("%s not found\n", id);
 243                 return -1;
 244         }
 245
 246         data = *datap;
 247
 248         switch (data->kind) {
 249         case EXPR_ID_DATA__VALUE:
 250                 pr_debug2("lookup(%s): val %f\n", id, data->val.val);
 251                 break;
 252         case EXPR_ID_DATA__REF:
 253                 pr_debug2("lookup(%s): ref metric name %s\n", id,
 254                         data->ref.metric_name);
 255                 pr_debug("processing metric: %s ENTRY\n", id);
 256                 data->kind = EXPR_ID_DATA__REF_VALUE;
 257                 if (expr__parse(&data->ref.val, ctx, data->ref.metric_expr)) {
 258                         pr_debug("%s failed to count\n", id);
 259                         return -1;
 260                 }
 261                 pr_debug("processing metric: %s EXIT: %f\n", id, data->ref.val);
 262                 break;
 263         case EXPR_ID_DATA__REF_VALUE:
 264                 pr_debug2("lookup(%s): ref val %f metric name %s\n", id,
 265                         data->ref.val, data->ref.metric_name);
 266                 break;
 267         default:
 268                 assert(0);  /* Unreachable. */
 269         }
 270
 271         return 0;
 272 }
 273
 274 void expr__del_id(struct expr_parse_ctx *ctx, const char *id)
 275 {
 276         struct expr_id_data *old_val = NULL;
 277         char *old_key = NULL;
 278
 279         hashmap__delete(ctx->ids, id, &old_key, &old_val);
 280         free(old_key);
 281         free(old_val);
 282 }
 283
 284 struct expr_parse_ctx *expr__ctx_new(void)
 285 {
 286         struct expr_parse_ctx *ctx;
 287
 288         ctx = malloc(sizeof(struct expr_parse_ctx));
 289         if (!ctx)
 290                 return NULL;
 291
 292         ctx->ids = hashmap__new(key_hash, key_equal, NULL);
 293         if (IS_ERR(ctx->ids)) {
 294                 free(ctx);
 295                 return NULL;
 296         }
 297         ctx->sctx.user_requested_cpu_list = NULL;
 298         ctx->sctx.runtime = 0;
 299         ctx->sctx.system_wide = false;
 300
 301         return ctx;
 302 }
 303
 304 void expr__ctx_clear(struct expr_parse_ctx *ctx)
 305 {
 306         struct hashmap_entry *cur;
 307         size_t bkt;
 308
 309         hashmap__for_each_entry(ctx->ids, cur, bkt) {
 310                 zfree(&cur->pkey);
 311                 zfree(&cur->pvalue);
 312         }
 313         hashmap__clear(ctx->ids);
 314 }
 315
 316 void expr__ctx_free(struct expr_parse_ctx *ctx)
 317 {
 318         struct hashmap_entry *cur;
 319         size_t bkt;
 320
 321         if (!ctx)
 322                 return;
 323
 324         zfree(&ctx->sctx.user_requested_cpu_list);
 325         hashmap__for_each_entry(ctx->ids, cur, bkt) {
 326                 zfree(&cur->pkey);
 327                 zfree(&cur->pvalue);
 328         }
 329         hashmap__free(ctx->ids);
 330         free(ctx);
 331 }
 332
 333 static int
 334 __expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr,
 335               bool compute_ids)
 336 {
 337         YY_BUFFER_STATE buffer;
 338         void *scanner;
 339         int ret;
 340
 341         pr_debug2("parsing metric: %s\n", expr);
 342
 343         ret = expr_lex_init_extra(&ctx->sctx, &scanner);
 344         if (ret)
 345                 return ret;
 346
 347         buffer = expr__scan_string(expr, scanner);
 348
 349 #ifdef PARSER_DEBUG
 350         expr_debug = 1;
 351         expr_set_debug(1, scanner);
 352 #endif
 353
 354         ret = expr_parse(val, ctx, compute_ids, scanner);
 355
 356         expr__flush_buffer(buffer, scanner);
 357         expr__delete_buffer(buffer, scanner);
 358         expr_lex_destroy(scanner);
 359         return ret;
 360 }
 361
 362 int expr__parse(double *final_val, struct expr_parse_ctx *ctx,
 363                 const char *expr)
 364 {
 365         return __expr__parse(final_val, ctx, expr, /*compute_ids=*/false) ? -1 : 0;
 366 }
 367
 368 int expr__find_ids(const char *expr, const char *one,
 369                    struct expr_parse_ctx *ctx)
 370 {
 371         int ret = __expr__parse(NULL, ctx, expr, /*compute_ids=*/true);
 372
 373         if (one)
 374                 expr__del_id(ctx, one);
 375
 376         return ret;
 377 }
 378
 379 double expr_id_data__value(const struct expr_id_data *data)
 380 {
 381         if (data->kind == EXPR_ID_DATA__VALUE)
 382                 return data->val.val;
 383         assert(data->kind == EXPR_ID_DATA__REF_VALUE);
 384         return data->ref.val;
 385 }
 386
 387 double expr_id_data__source_count(const struct expr_id_data *data)
 388 {
 389         assert(data->kind == EXPR_ID_DATA__VALUE);
 390         return data->val.source_count;
 391 }
 392
 393 double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx)
 394 {
 395         double result = NAN;
 396         enum tool_pmu_event ev = tool_pmu__str_to_event(literal + 1);
 397
 398         if (ev != TOOL_PMU__EVENT_NONE) {
 399                 u64 count;
 400
 401                 if (tool_pmu__read_event(ev, &count))
 402                         result = count;
 403                 else
 404                         pr_err("Failure to read '%s'", literal);
 405
 406         } else if (!strcmp("#core_wide", literal)) {
 407                 result = core_wide(ctx->system_wide, ctx->user_requested_cpu_list)
 408                         ? 1.0 : 0.0;
 409         } else {
 410                 pr_err("Unrecognized literal '%s'", literal);
 411         }
 412
 413         pr_debug2("literal: %s = %f\n", literal, result);
 414         return result;
 415 }
 416
 417 /* Does the event 'id' parse? Determine via ctx->ids if possible. */
 418 double expr__has_event(const struct expr_parse_ctx *ctx, bool compute_ids, const char *id)
 419 {
 420         struct evlist *tmp;
 421         double ret;
 422
 423         if (hashmap__find(ctx->ids, id, /*value=*/NULL))
 424                 return 1.0;
 425
 426         if (!compute_ids)
 427                 return 0.0;
 428
 429         tmp = evlist__new();
 430         if (!tmp)
 431                 return NAN;
 432
 433         if (strchr(id, '@')) {
 434                 char *tmp_id, *p;
 435
 436                 tmp_id = strdup(id);
 437                 if (!tmp_id) {
 438                         ret = NAN;
 439                         goto out;
 440                 }
 441                 p = strchr(tmp_id, '@');
 442                 *p = '/';
 443                 p = strrchr(tmp_id, '@');
 444                 *p = '/';
 445                 ret = parse_event(tmp, tmp_id) ? 0 : 1;
 446                 free(tmp_id);
 447         } else {
 448                 ret = parse_event(tmp, id) ? 0 : 1;
 449         }
 450 out:
 451         evlist__delete(tmp);
 452         return ret;
 453 }
 454
 455 double expr__strcmp_cpuid_str(const struct expr_parse_ctx *ctx __maybe_unused,
 456                        bool compute_ids __maybe_unused, const char *test_id)
 457 {
 458         double ret;
 459         struct perf_cpu cpu = {-1};
 460         char *cpuid = get_cpuid_allow_env_override(cpu);
 461
 462         if (!cpuid)
 463                 return NAN;
 464
 465         ret = !strcmp_cpuid_str(test_id, cpuid);
 466
 467         free(cpuid);
 468         return ret;
 469 }