[deliverable/linux.git] / Documentation / perf_counter / util / parse-events.c


#include "../perf.h"
#include "util.h"
#include "parse-options.h"
#include "parse-events.h"
#include "exec_cmd.h"
#include "string.h"

extern char *strcasestr(const char *haystack, const char *needle);

int					nr_counters;

struct perf_counter_attr		attrs[MAX_COUNTERS];

struct event_symbol {
	__u8	type;
	__u64	config;
	char	*symbol;
};

#define C(x, y) .type = PERF_TYPE_##x, .config = PERF_COUNT_##y
#define CR(x, y) .type = PERF_TYPE_##x, .config = y

static struct event_symbol event_symbols[] = {
  { C(HARDWARE, CPU_CYCLES),		"cpu-cycles",		},
  { C(HARDWARE, CPU_CYCLES),		"cycles",		},
  { C(HARDWARE, INSTRUCTIONS),		"instructions",		},
  { C(HARDWARE, CACHE_REFERENCES),	"cache-references",	},
  { C(HARDWARE, CACHE_MISSES),		"cache-misses",		},
  { C(HARDWARE, BRANCH_INSTRUCTIONS),	"branch-instructions",	},
  { C(HARDWARE, BRANCH_INSTRUCTIONS),	"branches",		},
  { C(HARDWARE, BRANCH_MISSES),		"branch-misses",	},
  { C(HARDWARE, BUS_CYCLES),		"bus-cycles",		},

  { C(SOFTWARE, CPU_CLOCK),		"cpu-clock",		},
  { C(SOFTWARE, TASK_CLOCK),		"task-clock",		},
  { C(SOFTWARE, PAGE_FAULTS),		"page-faults",		},
  { C(SOFTWARE, PAGE_FAULTS),		"faults",		},
  { C(SOFTWARE, PAGE_FAULTS_MIN),	"minor-faults",		},
  { C(SOFTWARE, PAGE_FAULTS_MAJ),	"major-faults",		},
  { C(SOFTWARE, CONTEXT_SWITCHES),	"context-switches",	},
  { C(SOFTWARE, CONTEXT_SWITCHES),	"cs",			},
  { C(SOFTWARE, CPU_MIGRATIONS),	"cpu-migrations",	},
  { C(SOFTWARE, CPU_MIGRATIONS),	"migrations",		},
};

#define __PERF_COUNTER_FIELD(config, name) \
	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)

#define PERF_COUNTER_RAW(config)	__PERF_COUNTER_FIELD(config, RAW)
#define PERF_COUNTER_CONFIG(config)	__PERF_COUNTER_FIELD(config, CONFIG)
#define PERF_COUNTER_TYPE(config)	__PERF_COUNTER_FIELD(config, TYPE)
#define PERF_COUNTER_ID(config)		__PERF_COUNTER_FIELD(config, EVENT)

static char *hw_event_names[] = {
	"CPU cycles",
	"instructions",
	"cache references",
	"cache misses",
	"branches",
	"branch misses",
	"bus cycles",
};

static char *sw_event_names[] = {
	"cpu clock ticks",
	"task clock ticks",
	"pagefaults",
	"context switches",
	"CPU migrations",
	"minor faults",
	"major faults",
};

#define MAX_ALIASES 8

static char *hw_cache [][MAX_ALIASES] = {
	{ "l1-d" ,	"l1d" ,	"l1", "l1-data-cache"			},
	{ "l1-i" ,	"l1i" ,	"l1-instruction-cache"		},
	{ "l2"  , },
	{ "dtlb", },
	{ "itlb", },
	{ "bpu" , "btb", "branch-cache", NULL },
};

static char *hw_cache_op [][MAX_ALIASES] = {
	{ "read"	, "load" },
	{ "write"	, "store" },
	{ "prefetch"	, "speculative-read", "speculative-load" },
};

static char *hw_cache_result [][MAX_ALIASES] = {
	{ "access", "ops" },
	{ "miss", },
};

char *event_name(int counter)
{
	__u64 config = attrs[counter].config;
	int type = attrs[counter].type;
	static char buf[32];

	if (attrs[counter].type == PERF_TYPE_RAW) {
		sprintf(buf, "raw 0x%llx", config);
		return buf;
	}

	switch (type) {
	case PERF_TYPE_HARDWARE:
		if (config < PERF_HW_EVENTS_MAX)
			return hw_event_names[config];
		return "unknown-hardware";

	case PERF_TYPE_HW_CACHE: {
		__u8 cache_type, cache_op, cache_result;
		static char name[100];

		cache_type   = (config >>  0) & 0xff;
		if (cache_type > PERF_COUNT_HW_CACHE_MAX)
			return "unknown-ext-hardware-cache-type";

		cache_op     = (config >>  8) & 0xff;
		if (cache_type > PERF_COUNT_HW_CACHE_OP_MAX)
			return "unknown-ext-hardware-cache-op-type";

		cache_result = (config >> 16) & 0xff;
		if (cache_type > PERF_COUNT_HW_CACHE_RESULT_MAX)
			return "unknown-ext-hardware-cache-result-type";

		sprintf(name, "%s:%s:%s",
			hw_cache[cache_type][0],
			hw_cache_op[cache_op][0],
			hw_cache_result[cache_result][0]);

		return name;
	}

	case PERF_TYPE_SOFTWARE:
		if (config < PERF_SW_EVENTS_MAX)
			return sw_event_names[config];
		return "unknown-software";

	default:
		break;
	}

	return "unknown";
}

static int parse_aliases(const char *str, char *names[][MAX_ALIASES], int size)
{
	int i, j;

	for (i = 0; i < size; i++) {
		for (j = 0; j < MAX_ALIASES; j++) {
			if (!names[i][j])
				break;
			if (strcasestr(str, names[i][j]))
				return i;
		}
	}

	return 0;
}

static int parse_generic_hw_symbols(const char *str, struct perf_counter_attr *attr)
{
	__u8 cache_type = -1, cache_op = 0, cache_result = 0;

	cache_type = parse_aliases(str, hw_cache, PERF_COUNT_HW_CACHE_MAX);
	/*
	 * No fallback - if we cannot get a clear cache type
	 * then bail out:
	 */
	if (cache_type == -1)
		return -EINVAL;

	cache_op = parse_aliases(str, hw_cache_op, PERF_COUNT_HW_CACHE_OP_MAX);
	/*
	 * Fall back to reads:
	 */
	if (cache_type == -1)
		cache_type = PERF_COUNT_HW_CACHE_OP_READ;

	cache_result = parse_aliases(str, hw_cache_result,
					PERF_COUNT_HW_CACHE_RESULT_MAX);
	/*
	 * Fall back to accesses:
	 */
	if (cache_result == -1)
		cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;

	attr->config = cache_type | (cache_op << 8) | (cache_result << 16);
	attr->type = PERF_TYPE_HW_CACHE;

	return 0;
}

/*
 * Each event can have multiple symbolic names.
 * Symbolic names are (almost) exactly matched.
 */
static int parse_event_symbols(const char *str, struct perf_counter_attr *attr)
{
	__u64 config, id;
	int type;
	unsigned int i;
	const char *sep, *pstr;

	if (str[0] == 'r' && hex2u64(str + 1, &config) > 0) {
		attr->type = PERF_TYPE_RAW;
		attr->config = config;

		return 0;
	}

	pstr = str;
	sep = strchr(pstr, ':');
	if (sep) {
		type = atoi(pstr);
		pstr = sep + 1;
		id = atoi(pstr);
		sep = strchr(pstr, ':');
		if (sep) {
			pstr = sep + 1;
			if (strchr(pstr, 'k'))
				attr->exclude_user = 1;
			if (strchr(pstr, 'u'))
				attr->exclude_kernel = 1;
		}
		attr->type = type;
		attr->config = id;

		return 0;
	}

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
		if (!strncmp(str, event_symbols[i].symbol,
			     strlen(event_symbols[i].symbol))) {

			attr->type = event_symbols[i].type;
			attr->config = event_symbols[i].config;

			return 0;
		}
	}

	return parse_generic_hw_symbols(str, attr);
}

int parse_events(const struct option *opt, const char *str, int unset)
{
	struct perf_counter_attr attr;
	int ret;

	memset(&attr, 0, sizeof(attr));
again:
	if (nr_counters == MAX_COUNTERS)
		return -1;

	ret = parse_event_symbols(str, &attr);
	if (ret < 0)
		return ret;

	attrs[nr_counters] = attr;
	nr_counters++;

	str = strstr(str, ",");
	if (str) {
		str++;
		goto again;
	}

	return 0;
}

/*
 * Create the help text for the event symbols:
 */
void create_events_help(char *events_help_msg)
{
	unsigned int i;
	char *str;

	str = events_help_msg;

	str += sprintf(str,
	"event name: [");

	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
		int type, id;

		type = event_symbols[i].type;
		id = event_symbols[i].config;

		if (i)
			str += sprintf(str, "|");

		str += sprintf(str, "%s",
				event_symbols[i].symbol);
	}

	str += sprintf(str, "|rNNN]");
}
Commit	Line	Data
8ad8db37 IM	1
	2	#include "../perf.h"
	3	#include "util.h"
	4	#include "parse-options.h"
	5	#include "parse-events.h"
	6	#include "exec_cmd.h"
a0055ae2	7	#include "string.h"
8ad8db37	8
8326f44d IM	9	extern char strcasestr(const char haystack, const char *needle);
8326f44d IM	10
a21ca2ca	11	int nr_counters;
8ad8db37	12
a21ca2ca	13	struct perf_counter_attr attrs[MAX_COUNTERS];
8ad8db37 IM	14
8ad8db37 IM	15	struct event_symbol {
a21ca2ca IM	16	__u8 type;
	17	__u64 config;
	18	char *symbol;
8ad8db37 IM	19	};
8ad8db37 IM	20
a21ca2ca	21	#define C(x, y) .type = PERF_TYPE_##x, .config = PERF_COUNT_##y
8326f44d	22	#define CR(x, y) .type = PERF_TYPE_##x, .config = y
a21ca2ca	23
8ad8db37	24	static struct event_symbol event_symbols[] = {
a21ca2ca IM	25	{ C(HARDWARE, CPU_CYCLES), "cpu-cycles", },
	26	{ C(HARDWARE, CPU_CYCLES), "cycles", },
	27	{ C(HARDWARE, INSTRUCTIONS), "instructions", },
	28	{ C(HARDWARE, CACHE_REFERENCES), "cache-references", },
	29	{ C(HARDWARE, CACHE_MISSES), "cache-misses", },
	30	{ C(HARDWARE, BRANCH_INSTRUCTIONS), "branch-instructions", },
	31	{ C(HARDWARE, BRANCH_INSTRUCTIONS), "branches", },
	32	{ C(HARDWARE, BRANCH_MISSES), "branch-misses", },
	33	{ C(HARDWARE, BUS_CYCLES), "bus-cycles", },
	34
	35	{ C(SOFTWARE, CPU_CLOCK), "cpu-clock", },
	36	{ C(SOFTWARE, TASK_CLOCK), "task-clock", },
	37	{ C(SOFTWARE, PAGE_FAULTS), "page-faults", },
	38	{ C(SOFTWARE, PAGE_FAULTS), "faults", },
	39	{ C(SOFTWARE, PAGE_FAULTS_MIN), "minor-faults", },
	40	{ C(SOFTWARE, PAGE_FAULTS_MAJ), "major-faults", },
	41	{ C(SOFTWARE, CONTEXT_SWITCHES), "context-switches", },
	42	{ C(SOFTWARE, CONTEXT_SWITCHES), "cs", },
	43	{ C(SOFTWARE, CPU_MIGRATIONS), "cpu-migrations", },
	44	{ C(SOFTWARE, CPU_MIGRATIONS), "migrations", },
8ad8db37 IM	45	};
8ad8db37 IM	46
5242519b IM	47	#define __PERF_COUNTER_FIELD(config, name) \
	48	((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
	49
	50	#define PERF_COUNTER_RAW(config) __PERF_COUNTER_FIELD(config, RAW)
	51	#define PERF_COUNTER_CONFIG(config) __PERF_COUNTER_FIELD(config, CONFIG)
	52	#define PERF_COUNTER_TYPE(config) __PERF_COUNTER_FIELD(config, TYPE)
	53	#define PERF_COUNTER_ID(config) __PERF_COUNTER_FIELD(config, EVENT)
	54
	55	static char *hw_event_names[] = {
	56	"CPU cycles",
	57	"instructions",
	58	"cache references",
	59	"cache misses",
	60	"branches",
	61	"branch misses",
	62	"bus cycles",
	63	};
	64
	65	static char *sw_event_names[] = {
	66	"cpu clock ticks",
	67	"task clock ticks",
	68	"pagefaults",
	69	"context switches",
	70	"CPU migrations",
	71	"minor faults",
	72	"major faults",
	73	};
	74
8326f44d IM	75	#define MAX_ALIASES 8
	76
	77	static char *hw_cache [][MAX_ALIASES] = {
	78	{ "l1-d" , "l1d" , "l1", "l1-data-cache" },
	79	{ "l1-i" , "l1i" , "l1-instruction-cache" },
	80	{ "l2" , },
	81	{ "dtlb", },
	82	{ "itlb", },
	83	{ "bpu" , "btb", "branch-cache", NULL },
	84	};
	85
	86	static char *hw_cache_op [][MAX_ALIASES] = {
	87	{ "read" , "load" },
	88	{ "write" , "store" },
	89	{ "prefetch" , "speculative-read", "speculative-load" },
	90	};
	91
	92	static char *hw_cache_result [][MAX_ALIASES] = {
	93	{ "access", "ops" },
	94	{ "miss", },
	95	};
	96
a21ca2ca	97	char *event_name(int counter)
5242519b	98	{
a21ca2ca IM	99	__u64 config = attrs[counter].config;
a21ca2ca IM	100	int type = attrs[counter].type;
5242519b IM	101	static char buf[32];
5242519b IM	102
a21ca2ca IM	103	if (attrs[counter].type == PERF_TYPE_RAW) {
a21ca2ca IM	104	sprintf(buf, "raw 0x%llx", config);
5242519b IM	105	return buf;
	106	}
	107
	108	switch (type) {
	109	case PERF_TYPE_HARDWARE:
a21ca2ca IM	110	if (config < PERF_HW_EVENTS_MAX)
a21ca2ca IM	111	return hw_event_names[config];
5242519b IM	112	return "unknown-hardware";
5242519b IM	113
8326f44d IM	114	case PERF_TYPE_HW_CACHE: {
	115	__u8 cache_type, cache_op, cache_result;
	116	static char name[100];
	117
	118	cache_type = (config >> 0) & 0xff;
	119	if (cache_type > PERF_COUNT_HW_CACHE_MAX)
	120	return "unknown-ext-hardware-cache-type";
	121
	122	cache_op = (config >> 8) & 0xff;
	123	if (cache_type > PERF_COUNT_HW_CACHE_OP_MAX)
	124	return "unknown-ext-hardware-cache-op-type";
	125
	126	cache_result = (config >> 16) & 0xff;
	127	if (cache_type > PERF_COUNT_HW_CACHE_RESULT_MAX)
	128	return "unknown-ext-hardware-cache-result-type";
	129
	130	sprintf(name, "%s:%s:%s",
	131	hw_cache[cache_type][0],
	132	hw_cache_op[cache_op][0],
	133	hw_cache_result[cache_result][0]);
	134
	135	return name;
	136	}
	137
5242519b	138	case PERF_TYPE_SOFTWARE:
a21ca2ca IM	139	if (config < PERF_SW_EVENTS_MAX)
a21ca2ca IM	140	return sw_event_names[config];
5242519b IM	141	return "unknown-software";
	142
	143	default:
	144	break;
	145	}
	146
	147	return "unknown";
	148	}
	149
8326f44d IM	150	static int parse_aliases(const char str, char names[][MAX_ALIASES], int size)
	151	{
	152	int i, j;
	153
	154	for (i = 0; i < size; i++) {
	155	for (j = 0; j < MAX_ALIASES; j++) {
	156	if (!names[i][j])
	157	break;
	158	if (strcasestr(str, names[i][j]))
	159	return i;
	160	}
	161	}
	162
	163	return 0;
	164	}
	165
	166	static int parse_generic_hw_symbols(const char str, struct perf_counter_attr attr)
	167	{
	168	__u8 cache_type = -1, cache_op = 0, cache_result = 0;
	169
	170	cache_type = parse_aliases(str, hw_cache, PERF_COUNT_HW_CACHE_MAX);
	171	/*
	172	* No fallback - if we cannot get a clear cache type
	173	* then bail out:
	174	*/
	175	if (cache_type == -1)
	176	return -EINVAL;
	177
	178	cache_op = parse_aliases(str, hw_cache_op, PERF_COUNT_HW_CACHE_OP_MAX);
	179	/*
	180	* Fall back to reads:
	181	*/
	182	if (cache_type == -1)
	183	cache_type = PERF_COUNT_HW_CACHE_OP_READ;
	184
	185	cache_result = parse_aliases(str, hw_cache_result,
	186	PERF_COUNT_HW_CACHE_RESULT_MAX);
	187	/*
	188	* Fall back to accesses:
	189	*/
	190	if (cache_result == -1)
	191	cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
	192
	193	attr->config = cache_type \| (cache_op << 8) \| (cache_result << 16);
	194	attr->type = PERF_TYPE_HW_CACHE;
	195
	196	return 0;
	197	}
	198
8ad8db37 IM	199	/*
	200	* Each event can have multiple symbolic names.
	201	* Symbolic names are (almost) exactly matched.
	202	*/
8326f44d	203	static int parse_event_symbols(const char str, struct perf_counter_attr attr)
8ad8db37 IM	204	{
	205	__u64 config, id;
	206	int type;
	207	unsigned int i;
a0055ae2	208	const char sep, pstr;
8ad8db37	209
a21ca2ca IM	210	if (str[0] == 'r' && hex2u64(str + 1, &config) > 0) {
	211	attr->type = PERF_TYPE_RAW;
	212	attr->config = config;
	213
	214	return 0;
	215	}
8ad8db37	216
a0055ae2 ACM	217	pstr = str;
	218	sep = strchr(pstr, ':');
	219	if (sep) {
	220	type = atoi(pstr);
	221	pstr = sep + 1;
	222	id = atoi(pstr);
	223	sep = strchr(pstr, ':');
	224	if (sep) {
	225	pstr = sep + 1;
	226	if (strchr(pstr, 'k'))
a21ca2ca	227	attr->exclude_user = 1;
a0055ae2	228	if (strchr(pstr, 'u'))
a21ca2ca	229	attr->exclude_kernel = 1;
a0055ae2	230	}
a21ca2ca IM	231	attr->type = type;
	232	attr->config = id;
	233
	234	return 0;
5242519b	235	}
8ad8db37 IM	236
	237	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	238	if (!strncmp(str, event_symbols[i].symbol,
a21ca2ca IM	239	strlen(event_symbols[i].symbol))) {
	240
	241	attr->type = event_symbols[i].type;
	242	attr->config = event_symbols[i].config;
	243
	244	return 0;
	245	}
8ad8db37 IM	246	}
8ad8db37 IM	247
8326f44d	248	return parse_generic_hw_symbols(str, attr);
8ad8db37 IM	249	}
	250
	251	int parse_events(const struct option opt, const char str, int unset)
	252	{
a21ca2ca IM	253	struct perf_counter_attr attr;
a21ca2ca IM	254	int ret;
8ad8db37	255
a21ca2ca	256	memset(&attr, 0, sizeof(attr));
8ad8db37 IM	257	again:
	258	if (nr_counters == MAX_COUNTERS)
	259	return -1;
	260
8326f44d	261	ret = parse_event_symbols(str, &attr);
a21ca2ca IM	262	if (ret < 0)
a21ca2ca IM	263	return ret;
8ad8db37	264
a21ca2ca	265	attrs[nr_counters] = attr;
8ad8db37 IM	266	nr_counters++;
	267
	268	str = strstr(str, ",");
	269	if (str) {
	270	str++;
	271	goto again;
	272	}
	273
	274	return 0;
	275	}
	276
8ad8db37 IM	277	/*
	278	* Create the help text for the event symbols:
	279	*/
	280	void create_events_help(char *events_help_msg)
	281	{
	282	unsigned int i;
	283	char *str;
8ad8db37 IM	284
	285	str = events_help_msg;
	286
	287	str += sprintf(str,
	288	"event name: [");
	289
	290	for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
	291	int type, id;
	292
a21ca2ca IM	293	type = event_symbols[i].type;
a21ca2ca IM	294	id = event_symbols[i].config;
8ad8db37 IM	295
	296	if (i)
	297	str += sprintf(str, "\|");
	298
	299	str += sprintf(str, "%s",
	300	event_symbols[i].symbol);
	301	}
	302
	303	str += sprintf(str, "\|rNNN]");
	304	}