[deliverable/linux.git] / tools / perf / util / stat.c

#include <math.h>
#include "stat.h"
#include "evlist.h"
#include "evsel.h"
#include "thread_map.h"

void update_stats(struct stats *stats, u64 val)
{
	double delta;

	stats->n++;
	delta = val - stats->mean;
	stats->mean += delta / stats->n;
	stats->M2 += delta*(val - stats->mean);

	if (val > stats->max)
		stats->max = val;

	if (val < stats->min)
		stats->min = val;
}

double avg_stats(struct stats *stats)
{
	return stats->mean;
}

/*
 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
 *
 *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
 * s^2 = -------------------------------
 *                  n - 1
 *
 * http://en.wikipedia.org/wiki/Stddev
 *
 * The std dev of the mean is related to the std dev by:
 *
 *             s
 * s_mean = -------
 *          sqrt(n)
 *
 */
double stddev_stats(struct stats *stats)
{
	double variance, variance_mean;

	if (stats->n < 2)
		return 0.0;

	variance = stats->M2 / (stats->n - 1);
	variance_mean = variance / stats->n;

	return sqrt(variance_mean);
}

double rel_stddev_stats(double stddev, double avg)
{
	double pct = 0.0;

	if (avg)
		pct = 100.0 * stddev/avg;

	return pct;
}

bool __perf_evsel_stat__is(struct perf_evsel *evsel,
			   enum perf_stat_evsel_id id)
{
	struct perf_stat_evsel *ps = evsel->priv;

	return ps->id == id;
}

#define ID(id, name) [PERF_STAT_EVSEL_ID__##id] = #name
static const char *id_str[PERF_STAT_EVSEL_ID__MAX] = {
	ID(NONE,		x),
	ID(CYCLES_IN_TX,	cpu/cycles-t/),
	ID(TRANSACTION_START,	cpu/tx-start/),
	ID(ELISION_START,	cpu/el-start/),
	ID(CYCLES_IN_TX_CP,	cpu/cycles-ct/),
};
#undef ID

void perf_stat_evsel_id_init(struct perf_evsel *evsel)
{
	struct perf_stat_evsel *ps = evsel->priv;
	int i;

	/* ps->id is 0 hence PERF_STAT_EVSEL_ID__NONE by default */

	for (i = 0; i < PERF_STAT_EVSEL_ID__MAX; i++) {
		if (!strcmp(perf_evsel__name(evsel), id_str[i])) {
			ps->id = i;
			break;
		}
	}
}

static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
{
	int i;
	struct perf_stat_evsel *ps = evsel->priv;

	for (i = 0; i < 3; i++)
		init_stats(&ps->res_stats[i]);

	perf_stat_evsel_id_init(evsel);
}

static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
{
	evsel->priv = zalloc(sizeof(struct perf_stat_evsel));
	if (evsel->priv == NULL)
		return -ENOMEM;
	perf_evsel__reset_stat_priv(evsel);
	return 0;
}

static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
{
	zfree(&evsel->priv);
}

static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel,
					     int ncpus, int nthreads)
{
	struct perf_counts *counts;

	counts = perf_counts__new(ncpus, nthreads);
	if (counts)
		evsel->prev_raw_counts = counts;

	return counts ? 0 : -ENOMEM;
}

static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
{
	perf_counts__delete(evsel->prev_raw_counts);
	evsel->prev_raw_counts = NULL;
}

static int perf_evsel__alloc_stats(struct perf_evsel *evsel, bool alloc_raw)
{
	int ncpus = perf_evsel__nr_cpus(evsel);
	int nthreads = thread_map__nr(evsel->threads);

	if (perf_evsel__alloc_stat_priv(evsel) < 0 ||
	    perf_evsel__alloc_counts(evsel, ncpus, nthreads) < 0 ||
	    (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel, ncpus, nthreads) < 0))
		return -ENOMEM;

	return 0;
}

int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
{
	struct perf_evsel *evsel;

	evlist__for_each(evlist, evsel) {
		if (perf_evsel__alloc_stats(evsel, alloc_raw))
			goto out_free;
	}

	return 0;

out_free:
	perf_evlist__free_stats(evlist);
	return -1;
}

void perf_evlist__free_stats(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

	evlist__for_each(evlist, evsel) {
		perf_evsel__free_stat_priv(evsel);
		perf_evsel__free_counts(evsel);
		perf_evsel__free_prev_raw_counts(evsel);
	}
}

void perf_evlist__reset_stats(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;

	evlist__for_each(evlist, evsel) {
		perf_evsel__reset_stat_priv(evsel);
		perf_evsel__reset_counts(evsel);
	}
}

static void zero_per_pkg(struct perf_evsel *counter)
{
	if (counter->per_pkg_mask)
		memset(counter->per_pkg_mask, 0, MAX_NR_CPUS);
}

static int check_per_pkg(struct perf_evsel *counter,
			 struct perf_counts_values *vals, int cpu, bool *skip)
{
	unsigned long *mask = counter->per_pkg_mask;
	struct cpu_map *cpus = perf_evsel__cpus(counter);
	int s;

	*skip = false;

	if (!counter->per_pkg)
		return 0;

	if (cpu_map__empty(cpus))
		return 0;

	if (!mask) {
		mask = zalloc(MAX_NR_CPUS);
		if (!mask)
			return -ENOMEM;

		counter->per_pkg_mask = mask;
	}

	/*
	 * we do not consider an event that has not run as a good
	 * instance to mark a package as used (skip=1). Otherwise
	 * we may run into a situation where the first CPU in a package
	 * is not running anything, yet the second is, and this function
	 * would mark the package as used after the first CPU and would
	 * not read the values from the second CPU.
	 */
	if (!(vals->run && vals->ena))
		return 0;

	s = cpu_map__get_socket(cpus, cpu, NULL);
	if (s < 0)
		return -1;

	*skip = test_and_set_bit(s, mask) == 1;
	return 0;
}

static int
process_counter_values(struct perf_stat_config *config, struct perf_evsel *evsel,
		       int cpu, int thread,
		       struct perf_counts_values *count)
{
	struct perf_counts_values *aggr = &evsel->counts->aggr;
	static struct perf_counts_values zero;
	bool skip = false;

	if (check_per_pkg(evsel, count, cpu, &skip)) {
		pr_err("failed to read per-pkg counter\n");
		return -1;
	}

	if (skip)
		count = &zero;

	switch (config->aggr_mode) {
	case AGGR_THREAD:
	case AGGR_CORE:
	case AGGR_SOCKET:
	case AGGR_NONE:
		if (!evsel->snapshot)
			perf_evsel__compute_deltas(evsel, cpu, thread, count);
		perf_counts_values__scale(count, config->scale, NULL);
		if (config->aggr_mode == AGGR_NONE)
			perf_stat__update_shadow_stats(evsel, count->values, cpu);
		break;
	case AGGR_GLOBAL:
		aggr->val += count->val;
		if (config->scale) {
			aggr->ena += count->ena;
			aggr->run += count->run;
		}
	case AGGR_UNSET:
	default:
		break;
	}

	return 0;
}

static int process_counter_maps(struct perf_stat_config *config,
				struct perf_evsel *counter)
{
	int nthreads = thread_map__nr(counter->threads);
	int ncpus = perf_evsel__nr_cpus(counter);
	int cpu, thread;

	if (counter->system_wide)
		nthreads = 1;

	for (thread = 0; thread < nthreads; thread++) {
		for (cpu = 0; cpu < ncpus; cpu++) {
			if (process_counter_values(config, counter, cpu, thread,
						   perf_counts(counter->counts, cpu, thread)))
				return -1;
		}
	}

	return 0;
}

int perf_stat_process_counter(struct perf_stat_config *config,
			      struct perf_evsel *counter)
{
	struct perf_counts_values *aggr = &counter->counts->aggr;
	struct perf_stat_evsel *ps = counter->priv;
	u64 *count = counter->counts->aggr.values;
	u64 val;
	int i, ret;

	aggr->val = aggr->ena = aggr->run = 0;

	/*
	 * We calculate counter's data every interval,
	 * and the display code shows ps->res_stats
	 * avg value. We need to zero the stats for
	 * interval mode, otherwise overall avg running
	 * averages will be shown for each interval.
	 */
	if (config->interval)
		init_stats(ps->res_stats);

	if (counter->per_pkg)
		zero_per_pkg(counter);

	ret = process_counter_maps(config, counter);
	if (ret)
		return ret;

	if (config->aggr_mode != AGGR_GLOBAL)
		return 0;

	if (!counter->snapshot)
		perf_evsel__compute_deltas(counter, -1, -1, aggr);
	perf_counts_values__scale(aggr, config->scale, &counter->counts->scaled);

	for (i = 0; i < 3; i++)
		update_stats(&ps->res_stats[i], count[i]);

	if (verbose) {
		fprintf(config->output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
			perf_evsel__name(counter), count[0], count[1], count[2]);
	}

	/*
	 * Save the full runtime - to allow normalization during printout:
	 */
	val = counter->scale * *count;
	perf_stat__update_shadow_stats(counter, &val, 0);

	return 0;
}

int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused,
				   union perf_event *event,
				   struct perf_session *session)
{
	struct perf_counts_values count;
	struct stat_event *st = &event->stat;
	struct perf_evsel *counter;

	count.val = st->val;
	count.ena = st->ena;
	count.run = st->run;

	counter = perf_evlist__id2evsel(session->evlist, st->id);
	if (!counter) {
		pr_err("Failed to resolve counter for stat event.\n");
		return -EINVAL;
	}

	*perf_counts(counter->counts, st->cpu, st->thread) = count;
	counter->supported = true;
	return 0;
}

size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp)
{
	struct stat_event *st = (struct stat_event *) event;
	size_t ret;

	ret  = fprintf(fp, "\n... id %" PRIu64 ", cpu %d, thread %d\n",
		       st->id, st->cpu, st->thread);
	ret += fprintf(fp, "... value %" PRIu64 ", enabled %" PRIu64 ", running %" PRIu64 "\n",
		       st->val, st->ena, st->run);

	return ret;
}

size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp)
{
	struct stat_round_event *rd = (struct stat_round_event *)event;
	size_t ret;

	ret = fprintf(fp, "\n... time %" PRIu64 ", type %s\n", rd->time,
		      rd->type == PERF_STAT_ROUND_TYPE__FINAL ? "FINAL" : "INTERVAL");

	return ret;
}

size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp)
{
	struct perf_stat_config sc;
	size_t ret;

	perf_event__read_stat_config(&sc, &event->stat_config);

	ret  = fprintf(fp, "\n");
	ret += fprintf(fp, "... aggr_mode %d\n", sc.aggr_mode);
	ret += fprintf(fp, "... scale     %d\n", sc.scale);
	ret += fprintf(fp, "... interval  %u\n", sc.interval);

	return ret;
}
Commit	Line	Data
0007ecea	1	#include <math.h>
0007ecea	2	#include "stat.h"
24e34f68	3	#include "evlist.h"
e2f56da1	4	#include "evsel.h"
24e34f68	5	#include "thread_map.h"
0007ecea XG	6
	7	void update_stats(struct stats *stats, u64 val)
	8	{
	9	double delta;
	10
	11	stats->n++;
	12	delta = val - stats->mean;
	13	stats->mean += delta / stats->n;
	14	stats->M2 += delta*(val - stats->mean);
ffe4f3c0 DA	15
	16	if (val > stats->max)
	17	stats->max = val;
	18
	19	if (val < stats->min)
	20	stats->min = val;
0007ecea XG	21	}
	22
	23	double avg_stats(struct stats *stats)
	24	{
	25	return stats->mean;
	26	}
	27
	28	/*
	29	* http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
	30	*
	31	* (\Sum n_i^2) - ((\Sum n_i)^2)/n
	32	* s^2 = -------------------------------
	33	* n - 1
	34	*
	35	* http://en.wikipedia.org/wiki/Stddev
	36	*
	37	* The std dev of the mean is related to the std dev by:
	38	*
	39	* s
	40	* s_mean = -------
	41	* sqrt(n)
	42	*
	43	*/
	44	double stddev_stats(struct stats *stats)
	45	{
	46	double variance, variance_mean;
	47
45528f7c	48	if (stats->n < 2)
0007ecea XG	49	return 0.0;
	50
	51	variance = stats->M2 / (stats->n - 1);
	52	variance_mean = variance / stats->n;
	53
	54	return sqrt(variance_mean);
	55	}
	56
	57	double rel_stddev_stats(double stddev, double avg)
	58	{
	59	double pct = 0.0;
	60
	61	if (avg)
	62	pct = 100.0 * stddev/avg;
	63
	64	return pct;
	65	}
e2f56da1 JO	66
	67	bool __perf_evsel_stat__is(struct perf_evsel *evsel,
	68	enum perf_stat_evsel_id id)
	69	{
581cc8a2	70	struct perf_stat_evsel *ps = evsel->priv;
e2f56da1 JO	71
	72	return ps->id == id;
	73	}
	74
	75	#define ID(id, name) [PERF_STAT_EVSEL_ID__##id] = #name
	76	static const char *id_str[PERF_STAT_EVSEL_ID__MAX] = {
4c358d5c JO	77	ID(NONE, x),
	78	ID(CYCLES_IN_TX, cpu/cycles-t/),
	79	ID(TRANSACTION_START, cpu/tx-start/),
	80	ID(ELISION_START, cpu/el-start/),
	81	ID(CYCLES_IN_TX_CP, cpu/cycles-ct/),
e2f56da1 JO	82	};
	83	#undef ID
	84
	85	void perf_stat_evsel_id_init(struct perf_evsel *evsel)
	86	{
581cc8a2	87	struct perf_stat_evsel *ps = evsel->priv;
e2f56da1 JO	88	int i;
	89
	90	/* ps->id is 0 hence PERF_STAT_EVSEL_ID__NONE by default */
	91
	92	for (i = 0; i < PERF_STAT_EVSEL_ID__MAX; i++) {
	93	if (!strcmp(perf_evsel__name(evsel), id_str[i])) {
	94	ps->id = i;
	95	break;
	96	}
	97	}
	98	}
a9a3a4d9	99
86a2cf31	100	static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
9689edfa JO	101	{
9689edfa JO	102	int i;
581cc8a2	103	struct perf_stat_evsel *ps = evsel->priv;
9689edfa JO	104
	105	for (i = 0; i < 3; i++)
	106	init_stats(&ps->res_stats[i]);
	107
	108	perf_stat_evsel_id_init(evsel);
	109	}
	110
86a2cf31	111	static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
9689edfa	112	{
581cc8a2	113	evsel->priv = zalloc(sizeof(struct perf_stat_evsel));
9689edfa JO	114	if (evsel->priv == NULL)
	115	return -ENOMEM;
	116	perf_evsel__reset_stat_priv(evsel);
	117	return 0;
	118	}
	119
86a2cf31	120	static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
9689edfa JO	121	{
	122	zfree(&evsel->priv);
	123	}
a939512d	124
86a2cf31 JO	125	static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel,
86a2cf31 JO	126	int ncpus, int nthreads)
a939512d JO	127	{
	128	struct perf_counts *counts;
	129
	130	counts = perf_counts__new(ncpus, nthreads);
	131	if (counts)
	132	evsel->prev_raw_counts = counts;
	133
	134	return counts ? 0 : -ENOMEM;
	135	}
	136
86a2cf31	137	static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
a939512d JO	138	{
	139	perf_counts__delete(evsel->prev_raw_counts);
	140	evsel->prev_raw_counts = NULL;
	141	}
24e34f68	142
86a2cf31	143	static int perf_evsel__alloc_stats(struct perf_evsel *evsel, bool alloc_raw)
a7d0a102 JO	144	{
	145	int ncpus = perf_evsel__nr_cpus(evsel);
	146	int nthreads = thread_map__nr(evsel->threads);
	147
	148	if (perf_evsel__alloc_stat_priv(evsel) < 0 \|\|
	149	perf_evsel__alloc_counts(evsel, ncpus, nthreads) < 0 \|\|
	150	(alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel, ncpus, nthreads) < 0))
	151	return -ENOMEM;
	152
	153	return 0;
	154	}
	155
24e34f68 JO	156	int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
	157	{
	158	struct perf_evsel *evsel;
24e34f68 JO	159
24e34f68 JO	160	evlist__for_each(evlist, evsel) {
a7d0a102	161	if (perf_evsel__alloc_stats(evsel, alloc_raw))
24e34f68 JO	162	goto out_free;
	163	}
	164
	165	return 0;
	166
	167	out_free:
	168	perf_evlist__free_stats(evlist);
	169	return -1;
	170	}
	171
	172	void perf_evlist__free_stats(struct perf_evlist *evlist)
	173	{
	174	struct perf_evsel *evsel;
	175
	176	evlist__for_each(evlist, evsel) {
	177	perf_evsel__free_stat_priv(evsel);
	178	perf_evsel__free_counts(evsel);
	179	perf_evsel__free_prev_raw_counts(evsel);
	180	}
	181	}
	182
	183	void perf_evlist__reset_stats(struct perf_evlist *evlist)
	184	{
	185	struct perf_evsel *evsel;
	186
	187	evlist__for_each(evlist, evsel) {
	188	perf_evsel__reset_stat_priv(evsel);
	189	perf_evsel__reset_counts(evsel);
	190	}
	191	}
f80010eb JO	192
	193	static void zero_per_pkg(struct perf_evsel *counter)
	194	{
	195	if (counter->per_pkg_mask)
	196	memset(counter->per_pkg_mask, 0, MAX_NR_CPUS);
	197	}
	198
02d8dabc SE	199	static int check_per_pkg(struct perf_evsel *counter,
02d8dabc SE	200	struct perf_counts_values vals, int cpu, bool skip)
f80010eb JO	201	{
	202	unsigned long *mask = counter->per_pkg_mask;
	203	struct cpu_map *cpus = perf_evsel__cpus(counter);
	204	int s;
	205
	206	*skip = false;
	207
	208	if (!counter->per_pkg)
	209	return 0;
	210
	211	if (cpu_map__empty(cpus))
	212	return 0;
	213
	214	if (!mask) {
	215	mask = zalloc(MAX_NR_CPUS);
	216	if (!mask)
	217	return -ENOMEM;
	218
	219	counter->per_pkg_mask = mask;
	220	}
	221
02d8dabc SE	222	/*
	223	* we do not consider an event that has not run as a good
	224	* instance to mark a package as used (skip=1). Otherwise
	225	* we may run into a situation where the first CPU in a package
	226	* is not running anything, yet the second is, and this function
	227	* would mark the package as used after the first CPU and would
	228	* not read the values from the second CPU.
	229	*/
	230	if (!(vals->run && vals->ena))
	231	return 0;
	232
1fe7a300	233	s = cpu_map__get_socket(cpus, cpu, NULL);
f80010eb JO	234	if (s < 0)
	235	return -1;
	236
	237	*skip = test_and_set_bit(s, mask) == 1;
	238	return 0;
	239	}
	240
	241	static int
	242	process_counter_values(struct perf_stat_config config, struct perf_evsel evsel,
	243	int cpu, int thread,
	244	struct perf_counts_values *count)
	245	{
	246	struct perf_counts_values *aggr = &evsel->counts->aggr;
	247	static struct perf_counts_values zero;
	248	bool skip = false;
	249
02d8dabc	250	if (check_per_pkg(evsel, count, cpu, &skip)) {
f80010eb JO	251	pr_err("failed to read per-pkg counter\n");
	252	return -1;
	253	}
	254
	255	if (skip)
	256	count = &zero;
	257
	258	switch (config->aggr_mode) {
	259	case AGGR_THREAD:
	260	case AGGR_CORE:
	261	case AGGR_SOCKET:
	262	case AGGR_NONE:
	263	if (!evsel->snapshot)
	264	perf_evsel__compute_deltas(evsel, cpu, thread, count);
	265	perf_counts_values__scale(count, config->scale, NULL);
	266	if (config->aggr_mode == AGGR_NONE)
	267	perf_stat__update_shadow_stats(evsel, count->values, cpu);
	268	break;
	269	case AGGR_GLOBAL:
	270	aggr->val += count->val;
	271	if (config->scale) {
	272	aggr->ena += count->ena;
	273	aggr->run += count->run;
	274	}
208df99e	275	case AGGR_UNSET:
f80010eb JO	276	default:
	277	break;
	278	}
	279
	280	return 0;
	281	}
	282
	283	static int process_counter_maps(struct perf_stat_config *config,
	284	struct perf_evsel *counter)
	285	{
	286	int nthreads = thread_map__nr(counter->threads);
	287	int ncpus = perf_evsel__nr_cpus(counter);
	288	int cpu, thread;
	289
	290	if (counter->system_wide)
	291	nthreads = 1;
	292
	293	for (thread = 0; thread < nthreads; thread++) {
	294	for (cpu = 0; cpu < ncpus; cpu++) {
	295	if (process_counter_values(config, counter, cpu, thread,
	296	perf_counts(counter->counts, cpu, thread)))
	297	return -1;
	298	}
	299	}
	300
	301	return 0;
	302	}
	303
	304	int perf_stat_process_counter(struct perf_stat_config *config,
	305	struct perf_evsel *counter)
	306	{
	307	struct perf_counts_values *aggr = &counter->counts->aggr;
581cc8a2	308	struct perf_stat_evsel *ps = counter->priv;
f80010eb	309	u64 *count = counter->counts->aggr.values;
f340c5fc	310	u64 val;
f80010eb JO	311	int i, ret;
	312
	313	aggr->val = aggr->ena = aggr->run = 0;
f80010eb	314
51fd2df1 JO	315	/*
	316	* We calculate counter's data every interval,
	317	* and the display code shows ps->res_stats
	318	* avg value. We need to zero the stats for
	319	* interval mode, otherwise overall avg running
	320	* averages will be shown for each interval.
	321	*/
	322	if (config->interval)
	323	init_stats(ps->res_stats);
	324
f80010eb JO	325	if (counter->per_pkg)
	326	zero_per_pkg(counter);
	327
	328	ret = process_counter_maps(config, counter);
	329	if (ret)
	330	return ret;
	331
	332	if (config->aggr_mode != AGGR_GLOBAL)
	333	return 0;
	334
	335	if (!counter->snapshot)
	336	perf_evsel__compute_deltas(counter, -1, -1, aggr);
	337	perf_counts_values__scale(aggr, config->scale, &counter->counts->scaled);
	338
	339	for (i = 0; i < 3; i++)
	340	update_stats(&ps->res_stats[i], count[i]);
	341
	342	if (verbose) {
	343	fprintf(config->output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
	344	perf_evsel__name(counter), count[0], count[1], count[2]);
	345	}
	346
	347	/*
	348	* Save the full runtime - to allow normalization during printout:
	349	*/
f340c5fc AK	350	val = counter->scale * *count;
f340c5fc AK	351	perf_stat__update_shadow_stats(counter, &val, 0);
f80010eb JO	352
	353	return 0;
	354	}
0ea0e355 JO	355
	356	int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused,
	357	union perf_event *event,
	358	struct perf_session *session)
	359	{
	360	struct perf_counts_values count;
	361	struct stat_event *st = &event->stat;
	362	struct perf_evsel *counter;
	363
	364	count.val = st->val;
	365	count.ena = st->ena;
	366	count.run = st->run;
	367
	368	counter = perf_evlist__id2evsel(session->evlist, st->id);
	369	if (!counter) {
	370	pr_err("Failed to resolve counter for stat event.\n");
	371	return -EINVAL;
	372	}
	373
	374	*perf_counts(counter->counts, st->cpu, st->thread) = count;
	375	counter->supported = true;
	376	return 0;
	377	}
e08a4564 JO	378
	379	size_t perf_event__fprintf_stat(union perf_event event, FILE fp)
	380	{
	381	struct stat_event st = (struct stat_event ) event;
	382	size_t ret;
	383
	384	ret = fprintf(fp, "\n... id %" PRIu64 ", cpu %d, thread %d\n",
	385	st->id, st->cpu, st->thread);
	386	ret += fprintf(fp, "... value %" PRIu64 ", enabled %" PRIu64 ", running %" PRIu64 "\n",
	387	st->val, st->ena, st->run);
	388
	389	return ret;
	390	}
	391
	392	size_t perf_event__fprintf_stat_round(union perf_event event, FILE fp)
	393	{
	394	struct stat_round_event rd = (struct stat_round_event )event;
	395	size_t ret;
	396
	397	ret = fprintf(fp, "\n... time %" PRIu64 ", type %s\n", rd->time,
	398	rd->type == PERF_STAT_ROUND_TYPE__FINAL ? "FINAL" : "INTERVAL");
	399
	400	return ret;
	401	}
	402
	403	size_t perf_event__fprintf_stat_config(union perf_event event, FILE fp)
	404	{
	405	struct perf_stat_config sc;
	406	size_t ret;
	407
	408	perf_event__read_stat_config(&sc, &event->stat_config);
	409
	410	ret = fprintf(fp, "\n");
	411	ret += fprintf(fp, "... aggr_mode %d\n", sc.aggr_mode);
	412	ret += fprintf(fp, "... scale %d\n", sc.scale);
	413	ret += fprintf(fp, "... interval %u\n", sc.interval);
	414
	415	return ret;
	416	}