[deliverable/linux.git] / tools / perf / tests / hists_common.c

#include "perf.h"
#include "util/debug.h"
#include "util/symbol.h"
#include "util/sort.h"
#include "util/evsel.h"
#include "util/evlist.h"
#include "util/machine.h"
#include "util/thread.h"
#include "tests/hists_common.h"

static struct {
	u32 pid;
	const char *comm;
} fake_threads[] = {
	{ FAKE_PID_PERF1, "perf" },
	{ FAKE_PID_PERF2, "perf" },
	{ FAKE_PID_BASH,  "bash" },
};

static struct {
	u32 pid;
	u64 start;
	const char *filename;
} fake_mmap_info[] = {
	{ FAKE_PID_PERF1, FAKE_MAP_PERF,   "perf" },
	{ FAKE_PID_PERF1, FAKE_MAP_LIBC,   "libc" },
	{ FAKE_PID_PERF1, FAKE_MAP_KERNEL, "[kernel]" },
	{ FAKE_PID_PERF2, FAKE_MAP_PERF,   "perf" },
	{ FAKE_PID_PERF2, FAKE_MAP_LIBC,   "libc" },
	{ FAKE_PID_PERF2, FAKE_MAP_KERNEL, "[kernel]" },
	{ FAKE_PID_BASH,  FAKE_MAP_BASH,   "bash" },
	{ FAKE_PID_BASH,  FAKE_MAP_LIBC,   "libc" },
	{ FAKE_PID_BASH,  FAKE_MAP_KERNEL, "[kernel]" },
};

struct fake_sym {
	u64 start;
	u64 length;
	const char *name;
};

static struct fake_sym perf_syms[] = {
	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "run_command" },
	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "cmd_record" },
};

static struct fake_sym bash_syms[] = {
	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "xmalloc" },
	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "xfree" },
};

static struct fake_sym libc_syms[] = {
	{ 700, 100, "malloc" },
	{ 800, 100, "free" },
	{ 900, 100, "realloc" },
	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "malloc" },
	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "free" },
	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "realloc" },
};

static struct fake_sym kernel_syms[] = {
	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "schedule" },
	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "page_fault" },
	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "sys_perf_event_open" },
};

static struct {
	const char *dso_name;
	struct fake_sym *syms;
	size_t nr_syms;
} fake_symbols[] = {
	{ "perf", perf_syms, ARRAY_SIZE(perf_syms) },
	{ "bash", bash_syms, ARRAY_SIZE(bash_syms) },
	{ "libc", libc_syms, ARRAY_SIZE(libc_syms) },
	{ "[kernel]", kernel_syms, ARRAY_SIZE(kernel_syms) },
};

struct machine *setup_fake_machine(struct machines *machines)
{
	struct machine *machine = machines__find(machines, HOST_KERNEL_ID);
	size_t i;

	if (machine == NULL) {
		pr_debug("Not enough memory for machine setup\n");
		return NULL;
	}

	for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
		struct thread *thread;

		thread = machine__findnew_thread(machine, fake_threads[i].pid,
						 fake_threads[i].pid);
		if (thread == NULL)
			goto out;

		thread__set_comm(thread, fake_threads[i].comm, 0);
		thread__put(thread);
	}

	for (i = 0; i < ARRAY_SIZE(fake_mmap_info); i++) {
		struct perf_sample sample = {
			.cpumode = PERF_RECORD_MISC_USER,
		};
		union perf_event fake_mmap_event = {
			.mmap = {
				.pid = fake_mmap_info[i].pid,
				.tid = fake_mmap_info[i].pid,
				.start = fake_mmap_info[i].start,
				.len = FAKE_MAP_LENGTH,
				.pgoff = 0ULL,
			},
		};

		strcpy(fake_mmap_event.mmap.filename,
		       fake_mmap_info[i].filename);

		machine__process_mmap_event(machine, &fake_mmap_event, &sample);
	}

	for (i = 0; i < ARRAY_SIZE(fake_symbols); i++) {
		size_t k;
		struct dso *dso;

		dso = machine__findnew_dso(machine, fake_symbols[i].dso_name);
		if (dso == NULL)
			goto out;

		/* emulate dso__load() */
		dso__set_loaded(dso, MAP__FUNCTION);

		for (k = 0; k < fake_symbols[i].nr_syms; k++) {
			struct symbol *sym;
			struct fake_sym *fsym = &fake_symbols[i].syms[k];

			sym = symbol__new(fsym->start, fsym->length,
					  STB_GLOBAL, fsym->name);
			if (sym == NULL) {
				dso__put(dso);
				goto out;
			}

			symbols__insert(&dso->symbols[MAP__FUNCTION], sym);
		}

		dso__put(dso);
	}

	return machine;

out:
	pr_debug("Not enough memory for machine setup\n");
	machine__delete_threads(machine);
	return NULL;
}

void print_hists_in(struct hists *hists)
{
	int i = 0;
	struct rb_root *root;
	struct rb_node *node;

	if (hists__has(hists, need_collapse))
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	pr_info("----- %s --------\n", __func__);
	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

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

		if (!he->filtered) {
			pr_info("%2d: entry: %-8s [%-8s] %20s: period = %"PRIu64"\n",
				i, thread__comm_str(he->thread),
				he->ms.map->dso->short_name,
				he->ms.sym->name, he->stat.period);
		}

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

void print_hists_out(struct hists *hists)
{
	int i = 0;
	struct rb_root *root;
	struct rb_node *node;

	root = &hists->entries;

	pr_info("----- %s --------\n", __func__);
	node = rb_first(root);
	while (node) {
		struct hist_entry *he;

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

		if (!he->filtered) {
			pr_info("%2d: entry: %8s:%5d [%-8s] %20s: period = %"PRIu64"/%"PRIu64"\n",
				i, thread__comm_str(he->thread), he->thread->tid,
				he->ms.map->dso->short_name,
				he->ms.sym->name, he->stat.period,
				he->stat_acc ? he->stat_acc->period : 0);
		}

		i++;
		node = rb_next(node);
	}
}
Commit	Line	Data
6e344a95 NK	1	#include "perf.h"
	2	#include "util/debug.h"
	3	#include "util/symbol.h"
	4	#include "util/sort.h"
	5	#include "util/evsel.h"
	6	#include "util/evlist.h"
	7	#include "util/machine.h"
	8	#include "util/thread.h"
	9	#include "tests/hists_common.h"
	10
	11	static struct {
	12	u32 pid;
	13	const char *comm;
	14	} fake_threads[] = {
a1891aa4 NK	15	{ FAKE_PID_PERF1, "perf" },
	16	{ FAKE_PID_PERF2, "perf" },
	17	{ FAKE_PID_BASH, "bash" },
6e344a95 NK	18	};
	19
	20	static struct {
	21	u32 pid;
	22	u64 start;
	23	const char *filename;
	24	} fake_mmap_info[] = {
a1891aa4 NK	25	{ FAKE_PID_PERF1, FAKE_MAP_PERF, "perf" },
	26	{ FAKE_PID_PERF1, FAKE_MAP_LIBC, "libc" },
	27	{ FAKE_PID_PERF1, FAKE_MAP_KERNEL, "[kernel]" },
	28	{ FAKE_PID_PERF2, FAKE_MAP_PERF, "perf" },
	29	{ FAKE_PID_PERF2, FAKE_MAP_LIBC, "libc" },
	30	{ FAKE_PID_PERF2, FAKE_MAP_KERNEL, "[kernel]" },
	31	{ FAKE_PID_BASH, FAKE_MAP_BASH, "bash" },
	32	{ FAKE_PID_BASH, FAKE_MAP_LIBC, "libc" },
	33	{ FAKE_PID_BASH, FAKE_MAP_KERNEL, "[kernel]" },
6e344a95 NK	34	};
	35
	36	struct fake_sym {
	37	u64 start;
	38	u64 length;
	39	const char *name;
	40	};
	41
	42	static struct fake_sym perf_syms[] = {
a1891aa4 NK	43	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
	44	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "run_command" },
	45	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "cmd_record" },
6e344a95 NK	46	};
	47
	48	static struct fake_sym bash_syms[] = {
a1891aa4 NK	49	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
	50	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "xmalloc" },
	51	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "xfree" },
6e344a95 NK	52	};
	53
	54	static struct fake_sym libc_syms[] = {
	55	{ 700, 100, "malloc" },
	56	{ 800, 100, "free" },
	57	{ 900, 100, "realloc" },
a1891aa4 NK	58	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "malloc" },
	59	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "free" },
	60	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "realloc" },
6e344a95 NK	61	};
	62
	63	static struct fake_sym kernel_syms[] = {
a1891aa4 NK	64	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "schedule" },
	65	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "page_fault" },
	66	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "sys_perf_event_open" },
6e344a95 NK	67	};
	68
	69	static struct {
	70	const char *dso_name;
	71	struct fake_sym *syms;
	72	size_t nr_syms;
	73	} fake_symbols[] = {
	74	{ "perf", perf_syms, ARRAY_SIZE(perf_syms) },
	75	{ "bash", bash_syms, ARRAY_SIZE(bash_syms) },
	76	{ "libc", libc_syms, ARRAY_SIZE(libc_syms) },
	77	{ "[kernel]", kernel_syms, ARRAY_SIZE(kernel_syms) },
	78	};
	79
	80	struct machine setup_fake_machine(struct machines machines)
	81	{
	82	struct machine *machine = machines__find(machines, HOST_KERNEL_ID);
	83	size_t i;
	84
	85	if (machine == NULL) {
	86	pr_debug("Not enough memory for machine setup\n");
	87	return NULL;
	88	}
	89
	90	for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
	91	struct thread *thread;
	92
	93	thread = machine__findnew_thread(machine, fake_threads[i].pid,
	94	fake_threads[i].pid);
	95	if (thread == NULL)
	96	goto out;
	97
	98	thread__set_comm(thread, fake_threads[i].comm, 0);
b91fc39f	99	thread__put(thread);
6e344a95 NK	100	}
	101
	102	for (i = 0; i < ARRAY_SIZE(fake_mmap_info); i++) {
473398a2 ACM	103	struct perf_sample sample = {
	104	.cpumode = PERF_RECORD_MISC_USER,
	105	};
6e344a95 NK	106	union perf_event fake_mmap_event = {
6e344a95 NK	107	.mmap = {
6e344a95 NK	108	.pid = fake_mmap_info[i].pid,
	109	.tid = fake_mmap_info[i].pid,
	110	.start = fake_mmap_info[i].start,
a1891aa4	111	.len = FAKE_MAP_LENGTH,
6e344a95 NK	112	.pgoff = 0ULL,
	113	},
	114	};
	115
	116	strcpy(fake_mmap_event.mmap.filename,
	117	fake_mmap_info[i].filename);
	118
473398a2	119	machine__process_mmap_event(machine, &fake_mmap_event, &sample);
6e344a95 NK	120	}
	121
	122	for (i = 0; i < ARRAY_SIZE(fake_symbols); i++) {
	123	size_t k;
	124	struct dso *dso;
	125
aa7cc2ae	126	dso = machine__findnew_dso(machine, fake_symbols[i].dso_name);
6e344a95 NK	127	if (dso == NULL)
	128	goto out;
	129
	130	/* emulate dso__load() */
	131	dso__set_loaded(dso, MAP__FUNCTION);
	132
	133	for (k = 0; k < fake_symbols[i].nr_syms; k++) {
	134	struct symbol *sym;
	135	struct fake_sym *fsym = &fake_symbols[i].syms[k];
	136
	137	sym = symbol__new(fsym->start, fsym->length,
	138	STB_GLOBAL, fsym->name);
d3a7c489 ACM	139	if (sym == NULL) {
d3a7c489 ACM	140	dso__put(dso);
6e344a95	141	goto out;
d3a7c489	142	}
6e344a95 NK	143
	144	symbols__insert(&dso->symbols[MAP__FUNCTION], sym);
	145	}
d3a7c489 ACM	146
d3a7c489 ACM	147	dso__put(dso);
6e344a95 NK	148	}
	149
	150	return machine;
	151
	152	out:
	153	pr_debug("Not enough memory for machine setup\n");
	154	machine__delete_threads(machine);
6e344a95 NK	155	return NULL;
6e344a95 NK	156	}
4e754e1c NK	157
	158	void print_hists_in(struct hists *hists)
	159	{
	160	int i = 0;
	161	struct rb_root *root;
	162	struct rb_node *node;
	163
52225036	164	if (hists__has(hists, need_collapse))
4e754e1c NK	165	root = &hists->entries_collapsed;
	166	else
	167	root = hists->entries_in;
	168
	169	pr_info("----- %s --------\n", __func__);
	170	node = rb_first(root);
	171	while (node) {
	172	struct hist_entry *he;
	173
	174	he = rb_entry(node, struct hist_entry, rb_node_in);
	175
	176	if (!he->filtered) {
	177	pr_info("%2d: entry: %-8s [%-8s] %20s: period = %"PRIu64"\n",
	178	i, thread__comm_str(he->thread),
	179	he->ms.map->dso->short_name,
	180	he->ms.sym->name, he->stat.period);
	181	}
	182
	183	i++;
	184	node = rb_next(node);
	185	}
	186	}
	187
	188	void print_hists_out(struct hists *hists)
	189	{
	190	int i = 0;
	191	struct rb_root *root;
	192	struct rb_node *node;
	193
	194	root = &hists->entries;
	195
	196	pr_info("----- %s --------\n", __func__);
	197	node = rb_first(root);
	198	while (node) {
	199	struct hist_entry *he;
	200
	201	he = rb_entry(node, struct hist_entry, rb_node);
	202
	203	if (!he->filtered) {
0506aecc	204	pr_info("%2d: entry: %8s:%5d [%-8s] %20s: period = %"PRIu64"/%"PRIu64"\n",
f21d1815	205	i, thread__comm_str(he->thread), he->thread->tid,
4e754e1c	206	he->ms.map->dso->short_name,
0506aecc NK	207	he->ms.sym->name, he->stat.period,
0506aecc NK	208	he->stat_acc ? he->stat_acc->period : 0);
4e754e1c NK	209	}
	210
	211	i++;
	212	node = rb_next(node);
	213	}
	214	}