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
 25struct 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
 48static 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
 61static bool key_equal(long key1, long key2, void *ctx __maybe_unused)
 62{
 63	return !strcmp((const char *)key1, (const char *)key2);
 64}
 65
 66struct 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
 76void 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
 92int 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
106struct 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 */
142int 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 */
148int 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 */
154int 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	} else if (old_data) {
172		data_ptr->val.val += old_data->val.val;
173		data_ptr->val.source_count += old_data->val.source_count;
174	}
175	free(old_key);
176	free(old_data);
177	return ret;
178}
179
180int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref)
181{
182	struct expr_id_data *data_ptr = NULL, *old_data = NULL;
183	char *old_key = NULL;
184	char *name;
185	int ret;
186
187	data_ptr = zalloc(sizeof(*data_ptr));
188	if (!data_ptr)
189		return -ENOMEM;
190
191	name = strdup(ref->metric_name);
192	if (!name) {
193		free(data_ptr);
194		return -ENOMEM;
195	}
196
197	/*
198	 * Intentionally passing just const char pointers,
199	 * originally from 'struct pmu_event' object.
200	 * We don't need to change them, so there's no
201	 * need to create our own copy.
202	 */
203	data_ptr->ref.metric_name = ref->metric_name;
204	data_ptr->ref.metric_expr = ref->metric_expr;
205	data_ptr->kind = EXPR_ID_DATA__REF;
206
207	ret = hashmap__set(ctx->ids, name, data_ptr, &old_key, &old_data);
208	if (ret)
209		free(data_ptr);
210
211	pr_debug2("adding ref metric %s: %s\n",
212		  ref->metric_name, ref->metric_expr);
213
214	free(old_key);
215	free(old_data);
216	return ret;
217}
218
219int expr__get_id(struct expr_parse_ctx *ctx, const char *id,
220		 struct expr_id_data **data)
221{
222	if (!ctx || !id)
223		return -1;
224	return hashmap__find(ctx->ids, id, data) ? 0 : -1;
225}
226
227bool expr__subset_of_ids(struct expr_parse_ctx *haystack,
228			 struct expr_parse_ctx *needles)
229{
230	struct hashmap_entry *cur;
231	size_t bkt;
232	struct expr_id_data *data;
233
234	hashmap__for_each_entry(needles->ids, cur, bkt) {
235		if (expr__get_id(haystack, cur->pkey, &data))
236			return false;
237	}
238	return true;
239}
240
241
242int expr__resolve_id(struct expr_parse_ctx *ctx, const char *id,
243		     struct expr_id_data **datap)
244{
245	struct expr_id_data *data;
246
247	if (expr__get_id(ctx, id, datap) || !*datap) {
248		pr_debug("%s not found\n", id);
249		return -1;
250	}
251
252	data = *datap;
253
254	switch (data->kind) {
255	case EXPR_ID_DATA__VALUE:
256		pr_debug2("lookup(%s): val %f\n", id, data->val.val);
257		break;
258	case EXPR_ID_DATA__REF:
259		pr_debug2("lookup(%s): ref metric name %s\n", id,
260			data->ref.metric_name);
261		pr_debug("processing metric: %s ENTRY\n", id);
262		data->kind = EXPR_ID_DATA__REF_VALUE;
263		if (expr__parse(&data->ref.val, ctx, data->ref.metric_expr)) {
264			pr_debug("%s failed to count\n", id);
265			return -1;
266		}
267		pr_debug("processing metric: %s EXIT: %f\n", id, data->ref.val);
268		break;
269	case EXPR_ID_DATA__REF_VALUE:
270		pr_debug2("lookup(%s): ref val %f metric name %s\n", id,
271			data->ref.val, data->ref.metric_name);
272		break;
273	default:
274		assert(0);  /* Unreachable. */
275	}
276
277	return 0;
278}
279
280void expr__del_id(struct expr_parse_ctx *ctx, const char *id)
281{
282	struct expr_id_data *old_val = NULL;
283	char *old_key = NULL;
284
285	hashmap__delete(ctx->ids, id, &old_key, &old_val);
286	free(old_key);
287	free(old_val);
288}
289
290struct expr_parse_ctx *expr__ctx_new(void)
291{
292	struct expr_parse_ctx *ctx;
293
294	ctx = calloc(1, sizeof(struct expr_parse_ctx));
295	if (!ctx)
296		return NULL;
297
298	ctx->ids = hashmap__new(key_hash, key_equal, NULL);
299	if (IS_ERR(ctx->ids)) {
300		free(ctx);
301		return NULL;
302	}
303
304	return ctx;
305}
306
307void expr__ctx_clear(struct expr_parse_ctx *ctx)
308{
309	struct hashmap_entry *cur;
310	size_t bkt;
311
312	hashmap__for_each_entry(ctx->ids, cur, bkt) {
313		zfree(&cur->pkey);
314		zfree(&cur->pvalue);
315	}
316	hashmap__clear(ctx->ids);
317}
318
319void expr__ctx_free(struct expr_parse_ctx *ctx)
320{
321	struct hashmap_entry *cur;
322	size_t bkt;
323
324	if (!ctx)
325		return;
326
327	zfree(&ctx->sctx.user_requested_cpu_list);
328	hashmap__for_each_entry(ctx->ids, cur, bkt) {
329		zfree(&cur->pkey);
330		zfree(&cur->pvalue);
331	}
332	hashmap__free(ctx->ids);
333	free(ctx);
334}
335
336static int
337__expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr,
338	      bool compute_ids)
339{
340	YY_BUFFER_STATE buffer;
341	void *scanner;
342	int ret;
343
344	pr_debug2("parsing metric: %s\n", expr);
345
346	ret = expr_lex_init_extra(&ctx->sctx, &scanner);
347	if (ret)
348		return ret;
349
350	buffer = expr__scan_string(expr, scanner);
351
352#ifdef PARSER_DEBUG
353	expr_debug = 1;
354	expr_set_debug(1, scanner);
355#endif
356
357	ret = expr_parse(val, ctx, compute_ids, scanner);
358
359	expr__flush_buffer(buffer, scanner);
360	expr__delete_buffer(buffer, scanner);
361	expr_lex_destroy(scanner);
362	return ret;
363}
364
365int expr__parse(double *final_val, struct expr_parse_ctx *ctx,
366		const char *expr)
367{
368	return __expr__parse(final_val, ctx, expr, /*compute_ids=*/false) ? -1 : 0;
369}
370
371int expr__find_ids(const char *expr, const char *one,
372		   struct expr_parse_ctx *ctx)
373{
374	int ret = __expr__parse(NULL, ctx, expr, /*compute_ids=*/true);
375
376	if (one)
377		expr__del_id(ctx, one);
378
379	return ret;
380}
381
382double expr_id_data__value(const struct expr_id_data *data)
383{
384	if (data->kind == EXPR_ID_DATA__VALUE)
385		return data->val.val;
386	assert(data->kind == EXPR_ID_DATA__REF_VALUE);
387	return data->ref.val;
388}
389
390double expr_id_data__source_count(const struct expr_id_data *data)
391{
392	assert(data->kind == EXPR_ID_DATA__VALUE);
393	return data->val.source_count;
394}
395
396double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx)
397{
398	double result = NAN;
399	enum tool_pmu_event ev = tool_pmu__str_to_event(literal + 1);
400
401	if (ev != TOOL_PMU__EVENT_NONE) {
402		u64 count;
403
404		if (tool_pmu__read_event(ev, /*evsel=*/NULL,
405					 ctx->system_wide, ctx->user_requested_cpu_list,
406					 &count))
407			result = count;
408		else
409			pr_err("Failure to read '%s'", literal);
410	} else {
411		pr_err("Unrecognized literal '%s'", literal);
412	}
413
414	pr_debug2("literal: %s = %f\n", literal, result);
415	return result;
416}
417
418/* Does the event 'id' parse? Determine via ctx->ids if possible. */
419double expr__has_event(const struct expr_parse_ctx *ctx, bool compute_ids, const char *id)
420{
421	struct evlist *tmp;
422	double ret;
423
424	if (hashmap__find(ctx->ids, id, /*value=*/NULL))
425		return 1.0;
426
427	if (!compute_ids)
428		return 0.0;
429
430	tmp = evlist__new();
431	if (!tmp)
432		return NAN;
433
434	if (strchr(id, '@')) {
435		char *tmp_id, *p;
436
437		tmp_id = strdup(id);
438		if (!tmp_id) {
439			ret = NAN;
440			goto out;
441		}
442		p = strchr(tmp_id, '@');
443		*p = '/';
444		p = strrchr(tmp_id, '@');
445		*p = '/';
446		ret = parse_event(tmp, tmp_id) ? 0 : 1;
447		free(tmp_id);
448	} else {
449		ret = parse_event(tmp, id) ? 0 : 1;
450	}
451out:
452	evlist__delete(tmp);
453	return ret;
454}
455
456double expr__strcmp_cpuid_str(const struct expr_parse_ctx *ctx __maybe_unused,
457		       bool compute_ids __maybe_unused, const char *test_id)
458{
459	double ret;
460	struct perf_cpu cpu = {-1};
461	char *cpuid = get_cpuid_allow_env_override(cpu);
462
463	if (!cpuid)
464		return NAN;
465
466	ret = !strcmp_cpuid_str(test_id, cpuid);
467
468	free(cpuid);
469	return ret;
470}