Commit 3d65f644 authored by Ian Rogers's avatar Ian Rogers Committed by Namhyung Kim
Browse files

perf stat-shadow: Read tool events directly 



When reading time values for metrics don't use the globals updated in
builtin-stat, just read the events as regular events. The only
exception is for time events where nanoseconds need converting to
seconds as metrics assume time metrics are in seconds.

Signed-off-by: default avatarIan Rogers <irogers@google.com>
Signed-off-by: default avatarNamhyung Kim <namhyung@kernel.org>
parent bdf96c4e

tools/perf/util/stat-shadow.c

+66 −83
Original line number Diff line number Diff line
@@ -27,7 +27,32 @@ void perf_stat__reset_shadow_stats(void) 
	memset(&ru_stats, 0, sizeof(ru_stats));

}



static int prepare_metric(const struct metric_expr *mexp,

static bool tool_pmu__is_time_event(const struct perf_stat_config *config,

				   const struct evsel *evsel, int *tool_aggr_idx)

{

	enum tool_pmu_event event = evsel__tool_event(evsel);

	int aggr_idx;



	if (event != TOOL_PMU__EVENT_DURATION_TIME &&

	    event != TOOL_PMU__EVENT_USER_TIME &&

	    event != TOOL_PMU__EVENT_SYSTEM_TIME)

		return false;



	if (config) {

		cpu_aggr_map__for_each_idx(aggr_idx, config->aggr_map) {

			if (config->aggr_map->map[aggr_idx].cpu.cpu == 0) {

				*tool_aggr_idx = aggr_idx;

				return true;

			}

		}

		pr_debug("Unexpected CPU0 missing in aggregation for tool event.\n");

	}

	*tool_aggr_idx = 0; /* Assume the first aggregation index works. */

	return true;

}



static int prepare_metric(struct perf_stat_config *config,

			  const struct metric_expr *mexp,

			  const struct evsel *evsel,

			  struct expr_parse_ctx *pctx,

			  int aggr_idx)
@@ -37,58 +62,18 @@ static int prepare_metric(const struct metric_expr *mexp, 
	int i;



	for (i = 0; metric_events[i]; i++) {

		char *n;

		double val;

		int source_count = 0;



		if (evsel__is_tool(metric_events[i])) {

			struct stats *stats;

			double scale;



			switch (evsel__tool_event(metric_events[i])) {

			case TOOL_PMU__EVENT_DURATION_TIME:

				stats = &walltime_nsecs_stats;

				scale = 1e-9;

				break;

			case TOOL_PMU__EVENT_USER_TIME:

				stats = &ru_stats.ru_utime_usec_stat;

				scale = 1e-6;

				break;

			case TOOL_PMU__EVENT_SYSTEM_TIME:

				stats = &ru_stats.ru_stime_usec_stat;

				scale = 1e-6;

				break;

			case TOOL_PMU__EVENT_NONE:

				pr_err("Invalid tool event 'none'");

				abort();

			case TOOL_PMU__EVENT_MAX:

				pr_err("Invalid tool event 'max'");

				abort();

			case TOOL_PMU__EVENT_HAS_PMEM:

			case TOOL_PMU__EVENT_NUM_CORES:

			case TOOL_PMU__EVENT_NUM_CPUS:

			case TOOL_PMU__EVENT_NUM_CPUS_ONLINE:

			case TOOL_PMU__EVENT_NUM_DIES:

			case TOOL_PMU__EVENT_NUM_PACKAGES:

			case TOOL_PMU__EVENT_SLOTS:

			case TOOL_PMU__EVENT_SMT_ON:

			case TOOL_PMU__EVENT_SYSTEM_TSC_FREQ:

			case TOOL_PMU__EVENT_CORE_WIDE:

			case TOOL_PMU__EVENT_TARGET_CPU:

			default:

				pr_err("Unexpected tool event '%s'", evsel__name(metric_events[i]));

				abort();

			}

			val = avg_stats(stats) * scale;

			source_count = 1;

		} else {

		int source_count = 0, tool_aggr_idx;

		bool is_tool_time =

			tool_pmu__is_time_event(config, metric_events[i], &tool_aggr_idx);

		struct perf_stat_evsel *ps = metric_events[i]->stats;

		struct perf_stat_aggr *aggr;

		char *n;

		double val;



		/*

			 * If there are multiple uncore PMUs and we're not

			 * reading the leader's stats, determine the stats for

			 * the appropriate uncore PMU.

		 * If there are multiple uncore PMUs and we're not reading the

		 * leader's stats, determine the stats for the appropriate

		 * uncore PMU.

		 */

		if (evsel && evsel->metric_leader &&

		    evsel->pmu != evsel->metric_leader->pmu &&
@@ -105,26 +90,24 @@ static int prepare_metric(const struct metric_expr *mexp, 
				break;

			}

		}

			aggr = &ps->aggr[aggr_idx];

			if (!aggr)

				break;



			if (!metric_events[i]->supported) {

		/* Time events are always on CPU0, the first aggregation index. */

		aggr = &ps->aggr[is_tool_time ? tool_aggr_idx : aggr_idx];

		if (!aggr || !metric_events[i]->supported) {

			/*

				 * Not supported events will have a count of 0,

				 * which can be confusing in a

				 * metric. Explicitly set the value to NAN. Not

				 * counted events (enable time of 0) are read as

				 * 0.

			 * Not supported events will have a count of 0, which

			 * can be confusing in a metric. Explicitly set the

			 * value to NAN. Not counted events (enable time of 0)

			 * are read as 0.

			 */

			val = NAN;

			source_count = 0;

		} else {

			val = aggr->counts.val;

			if (is_tool_time)

				val *= 1e-9; /* Convert time event nanoseconds to seconds. */

			if (!source_count)

				source_count = evsel__source_count(metric_events[i]);

		}

		}

		n = strdup(evsel__metric_id(metric_events[i]));

		if (!n)

			return -ENOMEM;
@@ -169,7 +152,7 @@ static void generic_metric(struct perf_stat_config *config, 
		pctx->sctx.user_requested_cpu_list = strdup(config->user_requested_cpu_list);

	pctx->sctx.runtime = runtime;

	pctx->sctx.system_wide = config->system_wide;

	i = prepare_metric(mexp, evsel, pctx, aggr_idx);

	i = prepare_metric(config, mexp, evsel, pctx, aggr_idx);

	if (i < 0) {

		expr__ctx_free(pctx);

		return;
@@ -230,7 +213,7 @@ double test_generic_metric(struct metric_expr *mexp, int aggr_idx) 
	if (!pctx)

		return NAN;



	if (prepare_metric(mexp, /*evsel=*/NULL, pctx, aggr_idx) < 0)

	if (prepare_metric(/*config=*/NULL, mexp, /*evsel=*/NULL, pctx, aggr_idx) < 0)

		goto out;



	if (expr__parse(&ratio, pctx, mexp->metric_expr))