[mirror_ubuntu-focal-kernel.git] / tools / perf / tests / hists_link.c

#include "perf.h"
#include "tests.h"
#include "debug.h"
#include "symbol.h"
#include "sort.h"
#include "evsel.h"
#include "evlist.h"
#include "machine.h"
#include "thread.h"
#include "parse-events.h"
#include "hists_common.h"
#include <errno.h>
#include <linux/kernel.h>

struct sample {
	u32 pid;
	u64 ip;
	struct thread *thread;
	struct map *map;
	struct symbol *sym;
};

/* For the numbers, see hists_common.c */
static struct sample fake_common_samples[] = {
	/* perf [kernel] schedule() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
	/* perf [perf]   main() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [perf]   cmd_record() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_CMD_RECORD, },
	/* bash [bash]   xmalloc() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XMALLOC, },
	/* bash [libc]   malloc() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_MALLOC, },
};

static struct sample fake_samples[][5] = {
	{
		/* perf [perf]   run_command() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_RUN_COMMAND, },
		/* perf [libc]   malloc() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
		/* perf [kernel] page_fault() */
		{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
		/* perf [kernel] sys_perf_event_open() */
		{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN, },
		/* bash [libc]   free() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_FREE, },
	},
	{
		/* perf [libc]   free() */
		{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_LIBC_FREE, },
		/* bash [libc]   malloc() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_MALLOC, }, /* will be merged */
		/* bash [bash]   xfee() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XFREE, },
		/* bash [libc]   realloc() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_LIBC_REALLOC, },
		/* bash [kernel] page_fault() */
		{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	},
};

static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
{
	struct perf_evsel *evsel;
	struct addr_location al;
	struct hist_entry *he;
	struct perf_sample sample = { .period = 1, .weight = 1, };
	size_t i = 0, k;

	/*
	 * each evsel will have 10 samples - 5 common and 5 distinct.
	 * However the second evsel also has a collapsed entry for
	 * "bash [libc] malloc" so total 9 entries will be in the tree.
	 */
	evlist__for_each_entry(evlist, evsel) {
		struct hists *hists = evsel__hists(evsel);

		for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
			sample.cpumode = PERF_RECORD_MISC_USER;
			sample.pid = fake_common_samples[k].pid;
			sample.tid = fake_common_samples[k].pid;
			sample.ip = fake_common_samples[k].ip;

			if (machine__resolve(machine, &al, &sample) < 0)
				goto out;

			he = hists__add_entry(hists, &al, NULL,
						NULL, NULL, &sample, true);
			if (he == NULL) {
				addr_location__put(&al);
				goto out;
			}

			fake_common_samples[k].thread = al.thread;
			fake_common_samples[k].map = al.map;
			fake_common_samples[k].sym = al.sym;
		}

		for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
			sample.pid = fake_samples[i][k].pid;
			sample.tid = fake_samples[i][k].pid;
			sample.ip = fake_samples[i][k].ip;
			if (machine__resolve(machine, &al, &sample) < 0)
				goto out;

			he = hists__add_entry(hists, &al, NULL,
						NULL, NULL, &sample, true);
			if (he == NULL) {
				addr_location__put(&al);
				goto out;
			}

			fake_samples[i][k].thread = al.thread;
			fake_samples[i][k].map = al.map;
			fake_samples[i][k].sym = al.sym;
		}
		i++;
	}

	return 0;

out:
	pr_debug("Not enough memory for adding a hist entry\n");
	return -1;
}

static int find_sample(struct sample *samples, size_t nr_samples,
		       struct thread *t, struct map *m, struct symbol *s)
{
	while (nr_samples--) {
		if (samples->thread == t && samples->map == m &&
		    samples->sym == s)
			return 1;
		samples++;
	}
	return 0;
}

static int __validate_match(struct hists *hists)
{
	size_t count = 0;
	struct rb_root *root;
	struct rb_node *node;

	/*
	 * Only entries from fake_common_samples should have a pair.
	 */
	if (hists__has(hists, need_collapse))
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

		he = rb_entry(node, struct hist_entry, rb_node_in);

		if (hist_entry__has_pairs(he)) {
			if (find_sample(fake_common_samples,
					ARRAY_SIZE(fake_common_samples),
					he->thread, he->ms.map, he->ms.sym)) {
				count++;
			} else {
				pr_debug("Can't find the matched entry\n");
				return -1;
			}
		}

		node = rb_next(node);
	}

	if (count != ARRAY_SIZE(fake_common_samples)) {
		pr_debug("Invalid count for matched entries: %zd of %zd\n",
			 count, ARRAY_SIZE(fake_common_samples));
		return -1;
	}

	return 0;
}

static int validate_match(struct hists *leader, struct hists *other)
{
	return __validate_match(leader) || __validate_match(other);
}

static int __validate_link(struct hists *hists, int idx)
{
	size_t count = 0;
	size_t count_pair = 0;
	size_t count_dummy = 0;
	struct rb_root *root;
	struct rb_node *node;

	/*
	 * Leader hists (idx = 0) will have dummy entries from other,
	 * and some entries will have no pair.  However every entry
	 * in other hists should have (dummy) pair.
	 */
	if (hists__has(hists, need_collapse))
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

		he = rb_entry(node, struct hist_entry, rb_node_in);

		if (hist_entry__has_pairs(he)) {
			if (!find_sample(fake_common_samples,
					 ARRAY_SIZE(fake_common_samples),
					 he->thread, he->ms.map, he->ms.sym) &&
			    !find_sample(fake_samples[idx],
					 ARRAY_SIZE(fake_samples[idx]),
					 he->thread, he->ms.map, he->ms.sym)) {
				count_dummy++;
			}
			count_pair++;
		} else if (idx) {
			pr_debug("A entry from the other hists should have pair\n");
			return -1;
		}

		count++;
		node = rb_next(node);
	}

	/*
	 * Note that we have a entry collapsed in the other (idx = 1) hists.
	 */
	if (idx == 0) {
		if (count_dummy != ARRAY_SIZE(fake_samples[1]) - 1) {
			pr_debug("Invalid count of dummy entries: %zd of %zd\n",
				 count_dummy, ARRAY_SIZE(fake_samples[1]) - 1);
			return -1;
		}
		if (count != count_pair + ARRAY_SIZE(fake_samples[0])) {
			pr_debug("Invalid count of total leader entries: %zd of %zd\n",
				 count, count_pair + ARRAY_SIZE(fake_samples[0]));
			return -1;
		}
	} else {
		if (count != count_pair) {
			pr_debug("Invalid count of total other entries: %zd of %zd\n",
				 count, count_pair);
			return -1;
		}
		if (count_dummy > 0) {
			pr_debug("Other hists should not have dummy entries: %zd\n",
				 count_dummy);
			return -1;
		}
	}

	return 0;
}

static int validate_link(struct hists *leader, struct hists *other)
{
	return __validate_link(leader, 0) || __validate_link(other, 1);
}

int test__hists_link(int subtest __maybe_unused)
{
	int err = -1;
	struct hists *hists, *first_hists;
	struct machines machines;
	struct machine *machine = NULL;
	struct perf_evsel *evsel, *first;
	struct perf_evlist *evlist = perf_evlist__new();

	if (evlist == NULL)
                return -ENOMEM;

	err = parse_events(evlist, "cpu-clock", NULL);
	if (err)
		goto out;
	err = parse_events(evlist, "task-clock", NULL);
	if (err)
		goto out;

	err = TEST_FAIL;
	/* default sort order (comm,dso,sym) will be used */
	if (setup_sorting(NULL) < 0)
		goto out;

	machines__init(&machines);

	/* setup threads/dso/map/symbols also */
	machine = setup_fake_machine(&machines);
	if (!machine)
		goto out;

	if (verbose > 1)
		machine__fprintf(machine, stderr);

	/* process sample events */
	err = add_hist_entries(evlist, machine);
	if (err < 0)
		goto out;

	evlist__for_each_entry(evlist, evsel) {
		hists = evsel__hists(evsel);
		hists__collapse_resort(hists, NULL);

		if (verbose > 2)
			print_hists_in(hists);
	}

	first = perf_evlist__first(evlist);
	evsel = perf_evlist__last(evlist);

	first_hists = evsel__hists(first);
	hists = evsel__hists(evsel);

	/* match common entries */
	hists__match(first_hists, hists);
	err = validate_match(first_hists, hists);
	if (err)
		goto out;

	/* link common and/or dummy entries */
	hists__link(first_hists, hists);
	err = validate_link(first_hists, hists);
	if (err)
		goto out;

	err = 0;

out:
	/* tear down everything */
	perf_evlist__delete(evlist);
	reset_output_field();
	machines__exit(&machines);

	return err;
}
Commit	Line	Data
f8ebb0cd NK	1	#include "perf.h"
	2	#include "tests.h"
	3	#include "debug.h"
	4	#include "symbol.h"
	5	#include "sort.h"
	6	#include "evsel.h"
	7	#include "evlist.h"
	8	#include "machine.h"
	9	#include "thread.h"
	10	#include "parse-events.h"
6e344a95	11	#include "hists_common.h"
a43783ae	12	#include <errno.h>
877a7a11	13	#include <linux/kernel.h>
f8ebb0cd NK	14
	15	struct sample {
	16	u32 pid;
	17	u64 ip;
	18	struct thread *thread;
	19	struct map *map;
	20	struct symbol *sym;
	21	};
	22
6e344a95	23	/* For the numbers, see hists_common.c */
f8ebb0cd NK	24	static struct sample fake_common_samples[] = {
f8ebb0cd NK	25	/* perf [kernel] schedule() */
a1891aa4	26	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
f8ebb0cd	27	/* perf [perf] main() */
a1891aa4	28	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
f8ebb0cd	29	/* perf [perf] cmd_record() */
a1891aa4	30	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_CMD_RECORD, },
f8ebb0cd	31	/* bash [bash] xmalloc() */
a1891aa4	32	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, },
f8ebb0cd	33	/* bash [libc] malloc() */
a1891aa4	34	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_MALLOC, },
f8ebb0cd NK	35	};
	36
	37	static struct sample fake_samples[][5] = {
	38	{
	39	/* perf [perf] run_command() */
a1891aa4	40	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_RUN_COMMAND, },
f8ebb0cd	41	/* perf [libc] malloc() */
a1891aa4	42	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
f8ebb0cd	43	/* perf [kernel] page_fault() */
a1891aa4	44	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f8ebb0cd	45	/* perf [kernel] sys_perf_event_open() */
a1891aa4	46	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN, },
f8ebb0cd	47	/* bash [libc] free() */
a1891aa4	48	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_FREE, },
f8ebb0cd NK	49	},
	50	{
	51	/* perf [libc] free() */
a1891aa4	52	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_LIBC_FREE, },
f8ebb0cd	53	/* bash [libc] malloc() */
a1891aa4	54	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_MALLOC, }, /* will be merged */
f8ebb0cd	55	/* bash [bash] xfee() */
a1891aa4	56	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XFREE, },
f8ebb0cd	57	/* bash [libc] realloc() */
a1891aa4	58	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_LIBC_REALLOC, },
f8ebb0cd	59	/* bash [kernel] page_fault() */
a1891aa4	60	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f8ebb0cd NK	61	},
	62	};
	63
	64	static int add_hist_entries(struct perf_evlist evlist, struct machine machine)
	65	{
	66	struct perf_evsel *evsel;
	67	struct addr_location al;
	68	struct hist_entry *he;
fd36f3dd	69	struct perf_sample sample = { .period = 1, .weight = 1, };
f8ebb0cd NK	70	size_t i = 0, k;
	71
	72	/*
	73	* each evsel will have 10 samples - 5 common and 5 distinct.
	74	* However the second evsel also has a collapsed entry for
	75	* "bash [libc] malloc" so total 9 entries will be in the tree.
	76	*/
e5cadb93	77	evlist__for_each_entry(evlist, evsel) {
4ea062ed ACM	78	struct hists *hists = evsel__hists(evsel);
4ea062ed ACM	79
f8ebb0cd	80	for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
473398a2	81	sample.cpumode = PERF_RECORD_MISC_USER;
ef89325f	82	sample.pid = fake_common_samples[k].pid;
13ce34df	83	sample.tid = fake_common_samples[k].pid;
ef89325f	84	sample.ip = fake_common_samples[k].ip;
bb3eb566 ACM	85
bb3eb566 ACM	86	if (machine__resolve(machine, &al, &sample) < 0)
f8ebb0cd NK	87	goto out;
f8ebb0cd NK	88
0102ef3e	89	he = hists__add_entry(hists, &al, NULL,
fd36f3dd	90	NULL, NULL, &sample, true);
b91fc39f ACM	91	if (he == NULL) {
b91fc39f ACM	92	addr_location__put(&al);
f8ebb0cd	93	goto out;
b91fc39f	94	}
f8ebb0cd NK	95
	96	fake_common_samples[k].thread = al.thread;
	97	fake_common_samples[k].map = al.map;
	98	fake_common_samples[k].sym = al.sym;
	99	}
	100
	101	for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
ef89325f	102	sample.pid = fake_samples[i][k].pid;
13ce34df	103	sample.tid = fake_samples[i][k].pid;
ef89325f	104	sample.ip = fake_samples[i][k].ip;
bb3eb566	105	if (machine__resolve(machine, &al, &sample) < 0)
f8ebb0cd NK	106	goto out;
f8ebb0cd NK	107
0102ef3e	108	he = hists__add_entry(hists, &al, NULL,
fd36f3dd	109	NULL, NULL, &sample, true);
b91fc39f ACM	110	if (he == NULL) {
b91fc39f ACM	111	addr_location__put(&al);
f8ebb0cd	112	goto out;
b91fc39f	113	}
f8ebb0cd NK	114
	115	fake_samples[i][k].thread = al.thread;
	116	fake_samples[i][k].map = al.map;
	117	fake_samples[i][k].sym = al.sym;
	118	}
	119	i++;
	120	}
	121
	122	return 0;
	123
	124	out:
	125	pr_debug("Not enough memory for adding a hist entry\n");
	126	return -1;
	127	}
	128
	129	static int find_sample(struct sample *samples, size_t nr_samples,
	130	struct thread t, struct map m, struct symbol *s)
	131	{
	132	while (nr_samples--) {
	133	if (samples->thread == t && samples->map == m &&
	134	samples->sym == s)
	135	return 1;
	136	samples++;
	137	}
	138	return 0;
	139	}
	140
	141	static int __validate_match(struct hists *hists)
	142	{
	143	size_t count = 0;
	144	struct rb_root *root;
	145	struct rb_node *node;
	146
	147	/*
	148	* Only entries from fake_common_samples should have a pair.
	149	*/
52225036	150	if (hists__has(hists, need_collapse))
f8ebb0cd NK	151	root = &hists->entries_collapsed;
	152	else
	153	root = hists->entries_in;
	154
	155	node = rb_first(root);
	156	while (node) {
	157	struct hist_entry *he;
	158
	159	he = rb_entry(node, struct hist_entry, rb_node_in);
	160
	161	if (hist_entry__has_pairs(he)) {
	162	if (find_sample(fake_common_samples,
	163	ARRAY_SIZE(fake_common_samples),
	164	he->thread, he->ms.map, he->ms.sym)) {
	165	count++;
	166	} else {
	167	pr_debug("Can't find the matched entry\n");
	168	return -1;
	169	}
	170	}
	171
	172	node = rb_next(node);
	173	}
	174
	175	if (count != ARRAY_SIZE(fake_common_samples)) {
	176	pr_debug("Invalid count for matched entries: %zd of %zd\n",
	177	count, ARRAY_SIZE(fake_common_samples));
	178	return -1;
	179	}
	180
	181	return 0;
	182	}
	183
	184	static int validate_match(struct hists leader, struct hists other)
	185	{
	186	return __validate_match(leader) \|\| __validate_match(other);
	187	}
	188
	189	static int __validate_link(struct hists *hists, int idx)
	190	{
	191	size_t count = 0;
	192	size_t count_pair = 0;
	193	size_t count_dummy = 0;
	194	struct rb_root *root;
	195	struct rb_node *node;
	196
	197	/*
	198	* Leader hists (idx = 0) will have dummy entries from other,
	199	* and some entries will have no pair. However every entry
	200	* in other hists should have (dummy) pair.
	201	*/
52225036	202	if (hists__has(hists, need_collapse))
f8ebb0cd NK	203	root = &hists->entries_collapsed;
	204	else
	205	root = hists->entries_in;
	206
	207	node = rb_first(root);
	208	while (node) {
	209	struct hist_entry *he;
	210
	211	he = rb_entry(node, struct hist_entry, rb_node_in);
	212
	213	if (hist_entry__has_pairs(he)) {
	214	if (!find_sample(fake_common_samples,
	215	ARRAY_SIZE(fake_common_samples),
	216	he->thread, he->ms.map, he->ms.sym) &&
	217	!find_sample(fake_samples[idx],
	218	ARRAY_SIZE(fake_samples[idx]),
	219	he->thread, he->ms.map, he->ms.sym)) {
	220	count_dummy++;
	221	}
	222	count_pair++;
	223	} else if (idx) {
	224	pr_debug("A entry from the other hists should have pair\n");
	225	return -1;
	226	}
	227
	228	count++;
	229	node = rb_next(node);
	230	}
	231
	232	/*
	233	* Note that we have a entry collapsed in the other (idx = 1) hists.
	234	*/
	235	if (idx == 0) {
	236	if (count_dummy != ARRAY_SIZE(fake_samples[1]) - 1) {
	237	pr_debug("Invalid count of dummy entries: %zd of %zd\n",
	238	count_dummy, ARRAY_SIZE(fake_samples[1]) - 1);
	239	return -1;
	240	}
	241	if (count != count_pair + ARRAY_SIZE(fake_samples[0])) {
	242	pr_debug("Invalid count of total leader entries: %zd of %zd\n",
	243	count, count_pair + ARRAY_SIZE(fake_samples[0]));
	244	return -1;
	245	}
	246	} else {
	247	if (count != count_pair) {
	248	pr_debug("Invalid count of total other entries: %zd of %zd\n",
	249	count, count_pair);
	250	return -1;
	251	}
	252	if (count_dummy > 0) {
	253	pr_debug("Other hists should not have dummy entries: %zd\n",
	254	count_dummy);
	255	return -1;
	256	}
	257	}
	258
	259	return 0;
	260	}
	261
	262	static int validate_link(struct hists leader, struct hists other)
	263	{
	264	return __validate_link(leader, 0) \|\| __validate_link(other, 1);
	265	}
	266
721a1f53	267	int test__hists_link(int subtest __maybe_unused)
f8ebb0cd NK	268	{
f8ebb0cd NK	269	int err = -1;
4ea062ed	270	struct hists hists, first_hists;
876650e6	271	struct machines machines;
f8ebb0cd NK	272	struct machine *machine = NULL;
f8ebb0cd NK	273	struct perf_evsel evsel, first;
334fe7a3	274	struct perf_evlist *evlist = perf_evlist__new();
f8ebb0cd NK	275
	276	if (evlist == NULL)
	277	return -ENOMEM;
	278
b39b8393	279	err = parse_events(evlist, "cpu-clock", NULL);
f8ebb0cd NK	280	if (err)
f8ebb0cd NK	281	goto out;
b39b8393	282	err = parse_events(evlist, "task-clock", NULL);
f8ebb0cd NK	283	if (err)
	284	goto out;
	285
b0500c16	286	err = TEST_FAIL;
f8ebb0cd	287	/* default sort order (comm,dso,sym) will be used */
40184c46	288	if (setup_sorting(NULL) < 0)
55309985	289	goto out;
f8ebb0cd	290
876650e6 ACM	291	machines__init(&machines);
876650e6 ACM	292
f8ebb0cd	293	/* setup threads/dso/map/symbols also */
876650e6	294	machine = setup_fake_machine(&machines);
f8ebb0cd NK	295	if (!machine)
	296	goto out;
	297
	298	if (verbose > 1)
	299	machine__fprintf(machine, stderr);
	300
	301	/* process sample events */
	302	err = add_hist_entries(evlist, machine);
	303	if (err < 0)
	304	goto out;
	305
e5cadb93	306	evlist__for_each_entry(evlist, evsel) {
4ea062ed ACM	307	hists = evsel__hists(evsel);
4ea062ed ACM	308	hists__collapse_resort(hists, NULL);
f8ebb0cd NK	309
f8ebb0cd NK	310	if (verbose > 2)
4ea062ed	311	print_hists_in(hists);
f8ebb0cd NK	312	}
	313
	314	first = perf_evlist__first(evlist);
	315	evsel = perf_evlist__last(evlist);
	316
4ea062ed ACM	317	first_hists = evsel__hists(first);
	318	hists = evsel__hists(evsel);
	319
f8ebb0cd	320	/* match common entries */
4ea062ed ACM	321	hists__match(first_hists, hists);
4ea062ed ACM	322	err = validate_match(first_hists, hists);
f8ebb0cd NK	323	if (err)
	324	goto out;
	325
	326	/* link common and/or dummy entries */
4ea062ed ACM	327	hists__link(first_hists, hists);
4ea062ed ACM	328	err = validate_link(first_hists, hists);
f8ebb0cd NK	329	if (err)
	330	goto out;
	331
	332	err = 0;
	333
	334	out:
	335	/* tear down everything */
	336	perf_evlist__delete(evlist);
f21d1815	337	reset_output_field();
876650e6	338	machines__exit(&machines);
f8ebb0cd NK	339
	340	return err;
	341	}