[linux-2.6-block.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"

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 = 100, .ip = 0xf0000 + 700, },
	/* perf [perf]   main() */
	{ .pid = 200, .ip = 0x40000 + 700, },
	/* perf [perf]   cmd_record() */
	{ .pid = 200, .ip = 0x40000 + 900, },
	/* bash [bash]   xmalloc() */
	{ .pid = 300, .ip = 0x40000 + 800, },
	/* bash [libc]   malloc() */
	{ .pid = 300, .ip = 0x50000 + 700, },
};

static struct sample fake_samples[][5] = {
	{
		/* perf [perf]   run_command() */
		{ .pid = 100, .ip = 0x40000 + 800, },
		/* perf [libc]   malloc() */
		{ .pid = 100, .ip = 0x50000 + 700, },
		/* perf [kernel] page_fault() */
		{ .pid = 100, .ip = 0xf0000 + 800, },
		/* perf [kernel] sys_perf_event_open() */
		{ .pid = 200, .ip = 0xf0000 + 900, },
		/* bash [libc]   free() */
		{ .pid = 300, .ip = 0x50000 + 800, },
	},
	{
		/* perf [libc]   free() */
		{ .pid = 200, .ip = 0x50000 + 800, },
		/* bash [libc]   malloc() */
		{ .pid = 300, .ip = 0x50000 + 700, }, /* will be merged */
		/* bash [bash]   xfee() */
		{ .pid = 300, .ip = 0x40000 + 900, },
		/* bash [libc]   realloc() */
		{ .pid = 300, .ip = 0x50000 + 900, },
		/* bash [kernel] page_fault() */
		{ .pid = 300, .ip = 0xf0000 + 800, },
	},
};

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 = { .cpu = 0, };
	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(evlist, evsel) {
		for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
			const union perf_event event = {
				.header = {
					.misc = 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 (perf_event__preprocess_sample(&event, machine, &al,
							  &sample) < 0)
				goto out;

			he = __hists__add_entry(&evsel->hists, &al, NULL,
						NULL, NULL, 1, 1, 0);
			if (he == NULL)
				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++) {
			const union perf_event event = {
				.header = {
					.misc = PERF_RECORD_MISC_USER,
				},
			};

			sample.pid = fake_samples[i][k].pid;
			sample.tid = fake_samples[i][k].pid;
			sample.ip = fake_samples[i][k].ip;
			if (perf_event__preprocess_sample(&event, machine, &al,
							  &sample) < 0)
				goto out;

			he = __hists__add_entry(&evsel->hists, &al, NULL,
						NULL, NULL, 1, 1, 0);
			if (he == NULL)
				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 (sort__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 (sort__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(void)
{
	int err = -1;
	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");
	if (err)
		goto out;
	err = parse_events(evlist, "task-clock");
	if (err)
		goto out;

	/* default sort order (comm,dso,sym) will be used */
	if (setup_sorting() < 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(evlist, evsel) {
		hists__collapse_resort(&evsel->hists, NULL);

		if (verbose > 2)
			print_hists_in(&evsel->hists);
	}

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

	/* match common entries */
	hists__match(&first->hists, &evsel->hists);
	err = validate_match(&first->hists, &evsel->hists);
	if (err)
		goto out;

	/* link common and/or dummy entries */
	hists__link(&first->hists, &evsel->hists);
	err = validate_link(&first->hists, &evsel->hists);
	if (err)
		goto out;

	err = 0;

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