[deliverable/linux.git] / tools / perf / tests / hists_output.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 "util/parse-events.h"
#include "tests/tests.h"
#include "tests/hists_common.h"

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

/* For the numbers, see hists_common.c */
static struct sample fake_samples[] = {
	/* perf [kernel] schedule() */
	{ .cpu = 0, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
	/* perf [perf]   main() */
	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [perf]   cmd_record() */
	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
	/* perf [libc]   malloc() */
	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
	/* perf [libc]   free() */
	{ .cpu = 2, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
	/* perf [perf]   main() */
	{ .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [kernel] page_fault() */
	{ .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	/* bash [bash]   main() */
	{ .cpu = 3, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_MAIN, },
	/* bash [bash]   xmalloc() */
	{ .cpu = 0, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XMALLOC, },
	/* bash [kernel] page_fault() */
	{ .cpu = 1, .pid = FAKE_PID_BASH,  .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
};

static int add_hist_entries(struct hists *hists, struct machine *machine)
{
	struct addr_location al;
	struct perf_evsel *evsel = hists_to_evsel(hists);
	struct perf_sample sample = { .period = 100, };
	size_t i;

	for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
		const union perf_event event = {
			.header = {
				.misc = PERF_RECORD_MISC_USER,
			},
		};
		struct hist_entry_iter iter = {
			.ops = &hist_iter_normal,
			.hide_unresolved = false,
		};

		sample.cpu = fake_samples[i].cpu;
		sample.pid = fake_samples[i].pid;
		sample.tid = fake_samples[i].pid;
		sample.ip = fake_samples[i].ip;

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

		if (hist_entry_iter__add(&iter, &al, evsel, &sample,
					 PERF_MAX_STACK_DEPTH, NULL) < 0)
			goto out;

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

	return TEST_OK;

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

static void del_hist_entries(struct hists *hists)
{
	struct hist_entry *he;
	struct rb_root *root_in;
	struct rb_root *root_out;
	struct rb_node *node;

	if (sort__need_collapse)
		root_in = &hists->entries_collapsed;
	else
		root_in = hists->entries_in;

	root_out = &hists->entries;

	while (!RB_EMPTY_ROOT(root_out)) {
		node = rb_first(root_out);

		he = rb_entry(node, struct hist_entry, rb_node);
		rb_erase(node, root_out);
		rb_erase(&he->rb_node_in, root_in);
		hist_entry__free(he);
	}
}

typedef int (*test_fn_t)(struct perf_evsel *, struct machine *);

#define COMM(he)  (thread__comm_str(he->thread))
#define DSO(he)   (he->ms.map->dso->short_name)
#define SYM(he)   (he->ms.sym->name)
#define CPU(he)   (he->cpu)
#define PID(he)   (he->thread->tid)

/* default sort keys (no field) */
static int test1(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = &evsel->hists;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;

	field_order = NULL;
	sort_order = NULL; /* equivalent to sort_order = "comm,dso,sym" */

	setup_sorting();

	/*
	 * expected output:
	 *
	 * Overhead  Command  Shared Object          Symbol
	 * ========  =======  =============  ==============
	 *   20.00%     perf  perf           [.] main
	 *   10.00%     bash  [kernel]       [k] page_fault
	 *   10.00%     bash  bash           [.] main
	 *   10.00%     bash  bash           [.] xmalloc
	 *   10.00%     perf  [kernel]       [k] page_fault
	 *   10.00%     perf  [kernel]       [k] schedule
	 *   10.00%     perf  libc           [.] free
	 *   10.00%     perf  libc           [.] malloc
	 *   10.00%     perf  perf           [.] cmd_record
	 */
	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	hists__collapse_resort(hists, NULL);
	hists__output_resort(hists);

	if (verbose > 2) {
		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
		print_hists_out(hists);
	}

	root = &evsel->hists.entries;
	node = rb_first(root);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			!strcmp(SYM(he), "main") && he->stat.period == 200);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "page_fault") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
			!strcmp(SYM(he), "main") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
			!strcmp(SYM(he), "xmalloc") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "page_fault") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "schedule") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
			!strcmp(SYM(he), "free") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
			!strcmp(SYM(he), "malloc") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			!strcmp(SYM(he), "cmd_record") && he->stat.period == 100);

out:
	del_hist_entries(hists);
	reset_output_field();
	return err;
}

/* mixed fields and sort keys */
static int test2(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = &evsel->hists;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;

	field_order = "overhead,cpu";
	sort_order = "pid";

	setup_sorting();

	/*
	 * expected output:
	 *
	 * Overhead  CPU  Command:  Pid
	 * ========  ===  =============
	 *   30.00%    1  perf   :  100
	 *   10.00%    0  perf   :  100
	 *   10.00%    2  perf   :  100
	 *   20.00%    2  perf   :  200
	 *   10.00%    0  bash   :  300
	 *   10.00%    1  bash   :  300
	 *   10.00%    3  bash   :  300
	 */
	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	hists__collapse_resort(hists, NULL);
	hists__output_resort(hists);

	if (verbose > 2) {
		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
		print_hists_out(hists);
	}

	root = &evsel->hists.entries;
	node = rb_first(root);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 1 && PID(he) == 100 && he->stat.period == 300);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 0 && PID(he) == 100 && he->stat.period == 100);

out:
	del_hist_entries(hists);
	reset_output_field();
	return err;
}

/* fields only (no sort key) */
static int test3(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = &evsel->hists;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;

	field_order = "comm,overhead,dso";
	sort_order = NULL;

	setup_sorting();

	/*
	 * expected output:
	 *
	 * Command  Overhead  Shared Object
	 * =======  ========  =============
	 *    bash    20.00%  bash
	 *    bash    10.00%  [kernel]
	 *    perf    30.00%  perf
	 *    perf    20.00%  [kernel]
	 *    perf    20.00%  libc
	 */
	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	hists__collapse_resort(hists, NULL);
	hists__output_resort(hists);

	if (verbose > 2) {
		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
		print_hists_out(hists);
	}

	root = &evsel->hists.entries;
	node = rb_first(root);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
			he->stat.period == 200);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
			he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			he->stat.period == 300);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
			he->stat.period == 200);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
			he->stat.period == 200);

out:
	del_hist_entries(hists);
	reset_output_field();
	return err;
}

/* handle duplicate 'dso' field */
static int test4(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = &evsel->hists;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;

	field_order = "dso,sym,comm,overhead,dso";
	sort_order = "sym";

	setup_sorting();

	/*
	 * expected output:
	 *
	 * Shared Object          Symbol  Command  Overhead
	 * =============  ==============  =======  ========
	 *          perf  [.] cmd_record     perf    10.00%
	 *          libc  [.] free           perf    10.00%
	 *          bash  [.] main           bash    10.00%
	 *          perf  [.] main           perf    20.00%
	 *          libc  [.] malloc         perf    10.00%
	 *      [kernel]  [k] page_fault     bash    10.00%
	 *      [kernel]  [k] page_fault     perf    10.00%
	 *      [kernel]  [k] schedule       perf    10.00%
	 *          bash  [.] xmalloc        bash    10.00%
	 */
	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	hists__collapse_resort(hists, NULL);
	hists__output_resort(hists);

	if (verbose > 2) {
		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
		print_hists_out(hists);
	}

	root = &evsel->hists.entries;
	node = rb_first(root);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "perf") && !strcmp(SYM(he), "cmd_record") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "libc") && !strcmp(SYM(he), "free") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "bash") && !strcmp(SYM(he), "main") &&
			!strcmp(COMM(he), "bash") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "perf") && !strcmp(SYM(he), "main") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 200);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "libc") && !strcmp(SYM(he), "malloc") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
			!strcmp(COMM(he), "bash") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "schedule") &&
			!strcmp(COMM(he), "perf") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			!strcmp(DSO(he), "bash") && !strcmp(SYM(he), "xmalloc") &&
			!strcmp(COMM(he), "bash") && he->stat.period == 100);

out:
	del_hist_entries(hists);
	reset_output_field();
	return err;
}

/* full sort keys w/o overhead field */
static int test5(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = &evsel->hists;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;

	field_order = "cpu,pid,comm,dso,sym";
	sort_order = "dso,pid";

	setup_sorting();

	/*
	 * expected output:
	 *
	 * CPU  Command:  Pid  Command  Shared Object          Symbol
	 * ===  =============  =======  =============  ==============
	 *   0     perf:  100     perf       [kernel]  [k] schedule
	 *   2     perf:  200     perf       [kernel]  [k] page_fault
	 *   1     bash:  300     bash       [kernel]  [k] page_fault
	 *   0     bash:  300     bash           bash  [.] xmalloc
	 *   3     bash:  300     bash           bash  [.] main
	 *   1     perf:  100     perf           libc  [.] malloc
	 *   2     perf:  100     perf           libc  [.] free
	 *   1     perf:  100     perf           perf  [.] cmd_record
	 *   1     perf:  100     perf           perf  [.] main
	 *   2     perf:  200     perf           perf  [.] main
	 */
	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	hists__collapse_resort(hists, NULL);
	hists__output_resort(hists);

	if (verbose > 2) {
		pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
		print_hists_out(hists);
	}

	root = &evsel->hists.entries;
	node = rb_first(root);
	he = rb_entry(node, struct hist_entry, rb_node);

	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 0 && PID(he) == 100 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "schedule") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 2 && PID(he) == 200 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "page_fault") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 1 && PID(he) == 300 &&
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
			!strcmp(SYM(he), "page_fault") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 0 && PID(he) == 300 &&
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
			!strcmp(SYM(he), "xmalloc") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 3 && PID(he) == 300 &&
			!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
			!strcmp(SYM(he), "main") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 1 && PID(he) == 100 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
			!strcmp(SYM(he), "malloc") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 2 && PID(he) == 100 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
			!strcmp(SYM(he), "free") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 1 && PID(he) == 100 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			!strcmp(SYM(he), "cmd_record") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 1 && PID(he) == 100 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			!strcmp(SYM(he), "main") && he->stat.period == 100);

	node = rb_next(node);
	he = rb_entry(node, struct hist_entry, rb_node);
	TEST_ASSERT_VAL("Invalid hist entry",
			CPU(he) == 2 && PID(he) == 200 &&
			!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
			!strcmp(SYM(he), "main") && he->stat.period == 100);

out:
	del_hist_entries(hists);
	reset_output_field();
	return err;
}

int test__hists_output(void)
{
	int err = TEST_FAIL;
	struct machines machines;
	struct machine *machine;
	struct perf_evsel *evsel;
	struct perf_evlist *evlist = perf_evlist__new();
	size_t i;
	test_fn_t testcases[] = {
		test1,
		test2,
		test3,
		test4,
		test5,
	};

	TEST_ASSERT_VAL("No memory", evlist);

	err = parse_events(evlist, "cpu-clock");
	if (err)
		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);

	evsel = perf_evlist__first(evlist);

	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
		err = testcases[i](evsel, machine);
		if (err < 0)
			break;
	}

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

	return err;
}
Commit	Line	Data
f21d1815 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 "util/parse-events.h"
	10	#include "tests/tests.h"
	11	#include "tests/hists_common.h"
	12
	13	struct sample {
	14	u32 cpu;
	15	u32 pid;
	16	u64 ip;
	17	struct thread *thread;
	18	struct map *map;
	19	struct symbol *sym;
	20	};
	21
	22	/* For the numbers, see hists_common.c */
	23	static struct sample fake_samples[] = {
	24	/* perf [kernel] schedule() */
a1891aa4	25	{ .cpu = 0, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
f21d1815	26	/* perf [perf] main() */
a1891aa4	27	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
f21d1815	28	/* perf [perf] cmd_record() */
a1891aa4	29	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
f21d1815	30	/* perf [libc] malloc() */
a1891aa4	31	{ .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
f21d1815	32	/* perf [libc] free() */
a1891aa4	33	{ .cpu = 2, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
f21d1815	34	/* perf [perf] main() */
a1891aa4	35	{ .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
f21d1815	36	/* perf [kernel] page_fault() */
a1891aa4	37	{ .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f21d1815	38	/* bash [bash] main() */
a1891aa4	39	{ .cpu = 3, .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_MAIN, },
f21d1815	40	/* bash [bash] xmalloc() */
a1891aa4	41	{ .cpu = 0, .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, },
f21d1815	42	/* bash [kernel] page_fault() */
a1891aa4	43	{ .cpu = 1, .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
f21d1815 NK	44	};
	45
	46	static int add_hist_entries(struct hists hists, struct machine machine)
	47	{
	48	struct addr_location al;
69bcb019	49	struct perf_evsel *evsel = hists_to_evsel(hists);
f21d1815 NK	50	struct perf_sample sample = { .period = 100, };
	51	size_t i;
	52
	53	for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
	54	const union perf_event event = {
	55	.header = {
	56	.misc = PERF_RECORD_MISC_USER,
	57	},
	58	};
69bcb019 NK	59	struct hist_entry_iter iter = {
	60	.ops = &hist_iter_normal,
	61	.hide_unresolved = false,
	62	};
f21d1815 NK	63
	64	sample.cpu = fake_samples[i].cpu;
	65	sample.pid = fake_samples[i].pid;
	66	sample.tid = fake_samples[i].pid;
	67	sample.ip = fake_samples[i].ip;
	68
	69	if (perf_event__preprocess_sample(&event, machine, &al,
	70	&sample) < 0)
	71	goto out;
	72
69bcb019	73	if (hist_entry_iter__add(&iter, &al, evsel, &sample,
9d3c02d7	74	PERF_MAX_STACK_DEPTH, NULL) < 0)
f21d1815 NK	75	goto out;
	76
	77	fake_samples[i].thread = al.thread;
	78	fake_samples[i].map = al.map;
	79	fake_samples[i].sym = al.sym;
	80	}
	81
	82	return TEST_OK;
	83
	84	out:
	85	pr_debug("Not enough memory for adding a hist entry\n");
	86	return TEST_FAIL;
	87	}
	88
	89	static void del_hist_entries(struct hists *hists)
	90	{
	91	struct hist_entry *he;
	92	struct rb_root *root_in;
	93	struct rb_root *root_out;
	94	struct rb_node *node;
	95
	96	if (sort__need_collapse)
	97	root_in = &hists->entries_collapsed;
	98	else
	99	root_in = hists->entries_in;
	100
	101	root_out = &hists->entries;
	102
	103	while (!RB_EMPTY_ROOT(root_out)) {
	104	node = rb_first(root_out);
	105
	106	he = rb_entry(node, struct hist_entry, rb_node);
	107	rb_erase(node, root_out);
	108	rb_erase(&he->rb_node_in, root_in);
	109	hist_entry__free(he);
	110	}
	111	}
	112
	113	typedef int (test_fn_t)(struct perf_evsel , struct machine *);
	114
	115	#define COMM(he) (thread__comm_str(he->thread))
	116	#define DSO(he) (he->ms.map->dso->short_name)
	117	#define SYM(he) (he->ms.sym->name)
	118	#define CPU(he) (he->cpu)
	119	#define PID(he) (he->thread->tid)
	120
	121	/* default sort keys (no field) */
	122	static int test1(struct perf_evsel evsel, struct machine machine)
	123	{
	124	int err;
	125	struct hists *hists = &evsel->hists;
	126	struct hist_entry *he;
	127	struct rb_root *root;
	128	struct rb_node *node;
	129
	130	field_order = NULL;
	131	sort_order = NULL; /* equivalent to sort_order = "comm,dso,sym" */
	132
	133	setup_sorting();
	134
	135	/*
	136	* expected output:
	137	*
	138	* Overhead Command Shared Object Symbol
139	* ======== ======= ============= ==============
140	* 20.00% perf perf [.] main
141	* 10.00% bash [kernel] [k] page_fault
142	* 10.00% bash bash [.] main
143	* 10.00% bash bash [.] xmalloc
144	* 10.00% perf [kernel] [k] page_fault
145	* 10.00% perf [kernel] [k] schedule
146	* 10.00% perf libc [.] free
147	* 10.00% perf libc [.] malloc
148	* 10.00% perf perf [.] cmd_record
149	*/
150	err = add_hist_entries(hists, machine);
151	if (err < 0)
152	goto out;
153
154	hists__collapse_resort(hists, NULL);
155	hists__output_resort(hists);
156
157	if (verbose > 2) {
158	pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
159	print_hists_out(hists);
160	}
161
162	root = &evsel->hists.entries;
163	node = rb_first(root);
164	he = rb_entry(node, struct hist_entry, rb_node);
165	TEST_ASSERT_VAL("Invalid hist entry",
166	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
167	!strcmp(SYM(he), "main") && he->stat.period == 200);
168
169	node = rb_next(node);
170	he = rb_entry(node, struct hist_entry, rb_node);
171	TEST_ASSERT_VAL("Invalid hist entry",
172	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
173	!strcmp(SYM(he), "page_fault") && he->stat.period == 100);
174
175	node = rb_next(node);
176	he = rb_entry(node, struct hist_entry, rb_node);
177	TEST_ASSERT_VAL("Invalid hist entry",
178	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
179	!strcmp(SYM(he), "main") && he->stat.period == 100);
180
181	node = rb_next(node);
182	he = rb_entry(node, struct hist_entry, rb_node);
183	TEST_ASSERT_VAL("Invalid hist entry",
184	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
185	!strcmp(SYM(he), "xmalloc") && he->stat.period == 100);
186
187	node = rb_next(node);
188	he = rb_entry(node, struct hist_entry, rb_node);
189	TEST_ASSERT_VAL("Invalid hist entry",
190	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
191	!strcmp(SYM(he), "page_fault") && he->stat.period == 100);
192
193	node = rb_next(node);
194	he = rb_entry(node, struct hist_entry, rb_node);
195	TEST_ASSERT_VAL("Invalid hist entry",
196	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
197	!strcmp(SYM(he), "schedule") && he->stat.period == 100);
198
199	node = rb_next(node);
200	he = rb_entry(node, struct hist_entry, rb_node);
201	TEST_ASSERT_VAL("Invalid hist entry",
202	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
203	!strcmp(SYM(he), "free") && he->stat.period == 100);
204
205	node = rb_next(node);
206	he = rb_entry(node, struct hist_entry, rb_node);
207	TEST_ASSERT_VAL("Invalid hist entry",
208	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
209	!strcmp(SYM(he), "malloc") && he->stat.period == 100);
210
211	node = rb_next(node);
212	he = rb_entry(node, struct hist_entry, rb_node);
213	TEST_ASSERT_VAL("Invalid hist entry",
214	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
215	!strcmp(SYM(he), "cmd_record") && he->stat.period == 100);
216
217	out:
218	del_hist_entries(hists);
219	reset_output_field();
220	return err;
221	}
222
223	/* mixed fields and sort keys */
224	static int test2(struct perf_evsel evsel, struct machine machine)
225	{
226	int err;
227	struct hists *hists = &evsel->hists;
228	struct hist_entry *he;
229	struct rb_root *root;
230	struct rb_node *node;
231
232	field_order = "overhead,cpu";
233	sort_order = "pid";
234
235	setup_sorting();
236
237	/*
238	* expected output:
239	*
240	* Overhead CPU Command: Pid
241	* ======== === =============
242	* 30.00% 1 perf : 100
243	* 10.00% 0 perf : 100
244	* 10.00% 2 perf : 100
245	* 20.00% 2 perf : 200
246	* 10.00% 0 bash : 300
247	* 10.00% 1 bash : 300
248	* 10.00% 3 bash : 300
249	*/
250	err = add_hist_entries(hists, machine);
251	if (err < 0)
252	goto out;
253
254	hists__collapse_resort(hists, NULL);
255	hists__output_resort(hists);
256
257	if (verbose > 2) {
258	pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
259	print_hists_out(hists);
260	}
261
262	root = &evsel->hists.entries;
263	node = rb_first(root);
264	he = rb_entry(node, struct hist_entry, rb_node);
265	TEST_ASSERT_VAL("Invalid hist entry",
266	CPU(he) == 1 && PID(he) == 100 && he->stat.period == 300);
267
268	node = rb_next(node);
269	he = rb_entry(node, struct hist_entry, rb_node);
270	TEST_ASSERT_VAL("Invalid hist entry",
271	CPU(he) == 0 && PID(he) == 100 && he->stat.period == 100);
272
273	out:
274	del_hist_entries(hists);
275	reset_output_field();
276	return err;
277	}
278
279	/* fields only (no sort key) */
280	static int test3(struct perf_evsel evsel, struct machine machine)
281	{
282	int err;
283	struct hists *hists = &evsel->hists;
284	struct hist_entry *he;
285	struct rb_root *root;
286	struct rb_node *node;
287
288	field_order = "comm,overhead,dso";
289	sort_order = NULL;
290
291	setup_sorting();
292
293	/*
294	* expected output:
295	*
296	* Command Overhead Shared Object
297	* ======= ======== =============
298	* bash 20.00% bash
299	* bash 10.00% [kernel]
300	* perf 30.00% perf
301	* perf 20.00% [kernel]
302	* perf 20.00% libc
303	*/
304	err = add_hist_entries(hists, machine);
305	if (err < 0)
306	goto out;
307
308	hists__collapse_resort(hists, NULL);
309	hists__output_resort(hists);
310
311	if (verbose > 2) {
312	pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
313	print_hists_out(hists);
314	}
315
316	root = &evsel->hists.entries;
317	node = rb_first(root);
318	he = rb_entry(node, struct hist_entry, rb_node);
319	TEST_ASSERT_VAL("Invalid hist entry",
320	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
321	he->stat.period == 200);
322
323	node = rb_next(node);
324	he = rb_entry(node, struct hist_entry, rb_node);
325	TEST_ASSERT_VAL("Invalid hist entry",
326	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
327	he->stat.period == 100);
328
329	node = rb_next(node);
330	he = rb_entry(node, struct hist_entry, rb_node);
331	TEST_ASSERT_VAL("Invalid hist entry",
332	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
333	he->stat.period == 300);
334
335	node = rb_next(node);
336	he = rb_entry(node, struct hist_entry, rb_node);
337	TEST_ASSERT_VAL("Invalid hist entry",
338	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
339	he->stat.period == 200);
340
341	node = rb_next(node);
342	he = rb_entry(node, struct hist_entry, rb_node);
343	TEST_ASSERT_VAL("Invalid hist entry",
344	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
345	he->stat.period == 200);
346
347	out:
348	del_hist_entries(hists);
349	reset_output_field();
350	return err;
351	}
352
353	/* handle duplicate 'dso' field */
354	static int test4(struct perf_evsel evsel, struct machine machine)
355	{
356	int err;
357	struct hists *hists = &evsel->hists;
358	struct hist_entry *he;
359	struct rb_root *root;
360	struct rb_node *node;
361
362	field_order = "dso,sym,comm,overhead,dso";
363	sort_order = "sym";
364
365	setup_sorting();
366
367	/*
368	* expected output:
369	*
370	* Shared Object Symbol Command Overhead
371	* ============= ============== ======= ========
372	* perf [.] cmd_record perf 10.00%
373	* libc [.] free perf 10.00%
374	* bash [.] main bash 10.00%
375	* perf [.] main perf 20.00%
376	* libc [.] malloc perf 10.00%
377	* [kernel] [k] page_fault bash 10.00%
378	* [kernel] [k] page_fault perf 10.00%
379	* [kernel] [k] schedule perf 10.00%
380	* bash [.] xmalloc bash 10.00%
381	*/
382	err = add_hist_entries(hists, machine);
383	if (err < 0)
384	goto out;
385
386	hists__collapse_resort(hists, NULL);
387	hists__output_resort(hists);
388
389	if (verbose > 2) {
390	pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
391	print_hists_out(hists);
392	}
393
394	root = &evsel->hists.entries;
395	node = rb_first(root);
396	he = rb_entry(node, struct hist_entry, rb_node);
397	TEST_ASSERT_VAL("Invalid hist entry",
398	!strcmp(DSO(he), "perf") && !strcmp(SYM(he), "cmd_record") &&
399	!strcmp(COMM(he), "perf") && he->stat.period == 100);
400
401	node = rb_next(node);
402	he = rb_entry(node, struct hist_entry, rb_node);
403	TEST_ASSERT_VAL("Invalid hist entry",
404	!strcmp(DSO(he), "libc") && !strcmp(SYM(he), "free") &&
405	!strcmp(COMM(he), "perf") && he->stat.period == 100);
406
407	node = rb_next(node);
408	he = rb_entry(node, struct hist_entry, rb_node);
409	TEST_ASSERT_VAL("Invalid hist entry",
410	!strcmp(DSO(he), "bash") && !strcmp(SYM(he), "main") &&
411	!strcmp(COMM(he), "bash") && he->stat.period == 100);
412
413	node = rb_next(node);
414	he = rb_entry(node, struct hist_entry, rb_node);
415	TEST_ASSERT_VAL("Invalid hist entry",
416	!strcmp(DSO(he), "perf") && !strcmp(SYM(he), "main") &&
417	!strcmp(COMM(he), "perf") && he->stat.period == 200);
418
419	node = rb_next(node);
420	he = rb_entry(node, struct hist_entry, rb_node);
421	TEST_ASSERT_VAL("Invalid hist entry",
422	!strcmp(DSO(he), "libc") && !strcmp(SYM(he), "malloc") &&
423	!strcmp(COMM(he), "perf") && he->stat.period == 100);
424
425	node = rb_next(node);
426	he = rb_entry(node, struct hist_entry, rb_node);
427	TEST_ASSERT_VAL("Invalid hist entry",
428	!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
429	!strcmp(COMM(he), "bash") && he->stat.period == 100);
430
431	node = rb_next(node);
432	he = rb_entry(node, struct hist_entry, rb_node);
433	TEST_ASSERT_VAL("Invalid hist entry",
434	!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") &&
435	!strcmp(COMM(he), "perf") && he->stat.period == 100);
436
437	node = rb_next(node);
438	he = rb_entry(node, struct hist_entry, rb_node);
439	TEST_ASSERT_VAL("Invalid hist entry",
440	!strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "schedule") &&
441	!strcmp(COMM(he), "perf") && he->stat.period == 100);
442
443	node = rb_next(node);
444	he = rb_entry(node, struct hist_entry, rb_node);
445	TEST_ASSERT_VAL("Invalid hist entry",
446	!strcmp(DSO(he), "bash") && !strcmp(SYM(he), "xmalloc") &&
447	!strcmp(COMM(he), "bash") && he->stat.period == 100);
448
449	out:
450	del_hist_entries(hists);
451	reset_output_field();
452	return err;
453	}
454
455	/* full sort keys w/o overhead field */
456	static int test5(struct perf_evsel evsel, struct machine machine)
457	{
458	int err;
459	struct hists *hists = &evsel->hists;
460	struct hist_entry *he;
461	struct rb_root *root;
462	struct rb_node *node;
463
464	field_order = "cpu,pid,comm,dso,sym";
465	sort_order = "dso,pid";
466
467	setup_sorting();
468
469	/*
470	* expected output:
471	*
472	* CPU Command: Pid Command Shared Object Symbol
473	* === ============= ======= ============= ==============
474	* 0 perf: 100 perf [kernel] [k] schedule
475	* 2 perf: 200 perf [kernel] [k] page_fault
476	* 1 bash: 300 bash [kernel] [k] page_fault
477	* 0 bash: 300 bash bash [.] xmalloc
478	* 3 bash: 300 bash bash [.] main
479	* 1 perf: 100 perf libc [.] malloc
480	* 2 perf: 100 perf libc [.] free
481	* 1 perf: 100 perf perf [.] cmd_record
482	* 1 perf: 100 perf perf [.] main
483	* 2 perf: 200 perf perf [.] main
484	*/
485	err = add_hist_entries(hists, machine);
486	if (err < 0)
487	goto out;
488
489	hists__collapse_resort(hists, NULL);
490	hists__output_resort(hists);
491
492	if (verbose > 2) {
493	pr_info("[fields = %s, sort = %s]\n", field_order, sort_order);
494	print_hists_out(hists);
495	}
496
497	root = &evsel->hists.entries;
498	node = rb_first(root);
499	he = rb_entry(node, struct hist_entry, rb_node);
500
501	TEST_ASSERT_VAL("Invalid hist entry",
502	CPU(he) == 0 && PID(he) == 100 &&
503	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
504	!strcmp(SYM(he), "schedule") && he->stat.period == 100);
505
506	node = rb_next(node);
507	he = rb_entry(node, struct hist_entry, rb_node);
508	TEST_ASSERT_VAL("Invalid hist entry",
509	CPU(he) == 2 && PID(he) == 200 &&
510	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") &&
511	!strcmp(SYM(he), "page_fault") && he->stat.period == 100);
512
513	node = rb_next(node);
514	he = rb_entry(node, struct hist_entry, rb_node);
515	TEST_ASSERT_VAL("Invalid hist entry",
516	CPU(he) == 1 && PID(he) == 300 &&
517	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") &&
518	!strcmp(SYM(he), "page_fault") && he->stat.period == 100);
519
520	node = rb_next(node);
521	he = rb_entry(node, struct hist_entry, rb_node);
522	TEST_ASSERT_VAL("Invalid hist entry",
523	CPU(he) == 0 && PID(he) == 300 &&
524	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
525	!strcmp(SYM(he), "xmalloc") && he->stat.period == 100);
526
527	node = rb_next(node);
528	he = rb_entry(node, struct hist_entry, rb_node);
529	TEST_ASSERT_VAL("Invalid hist entry",
530	CPU(he) == 3 && PID(he) == 300 &&
531	!strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") &&
532	!strcmp(SYM(he), "main") && he->stat.period == 100);
533
534	node = rb_next(node);
535	he = rb_entry(node, struct hist_entry, rb_node);
536	TEST_ASSERT_VAL("Invalid hist entry",
537	CPU(he) == 1 && PID(he) == 100 &&
538	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
539	!strcmp(SYM(he), "malloc") && he->stat.period == 100);
540
541	node = rb_next(node);
542	he = rb_entry(node, struct hist_entry, rb_node);
543	TEST_ASSERT_VAL("Invalid hist entry",
544	CPU(he) == 2 && PID(he) == 100 &&
545	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") &&
546	!strcmp(SYM(he), "free") && he->stat.period == 100);
547
548	node = rb_next(node);
549	he = rb_entry(node, struct hist_entry, rb_node);
550	TEST_ASSERT_VAL("Invalid hist entry",
551	CPU(he) == 1 && PID(he) == 100 &&
552	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
553	!strcmp(SYM(he), "cmd_record") && he->stat.period == 100);
554
555	node = rb_next(node);
556	he = rb_entry(node, struct hist_entry, rb_node);
557	TEST_ASSERT_VAL("Invalid hist entry",
558	CPU(he) == 1 && PID(he) == 100 &&
559	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
560	!strcmp(SYM(he), "main") && he->stat.period == 100);
561
562	node = rb_next(node);
563	he = rb_entry(node, struct hist_entry, rb_node);
564	TEST_ASSERT_VAL("Invalid hist entry",
565	CPU(he) == 2 && PID(he) == 200 &&
566	!strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") &&
567	!strcmp(SYM(he), "main") && he->stat.period == 100);
568
569	out:
570	del_hist_entries(hists);
571	reset_output_field();
572	return err;
573	}
574
575	int test__hists_output(void)
576	{
577	int err = TEST_FAIL;
578	struct machines machines;
579	struct machine *machine;
580	struct perf_evsel *evsel;
581	struct perf_evlist *evlist = perf_evlist__new();
582	size_t i;
583	test_fn_t testcases[] = {
584	test1,
585	test2,
586	test3,
587	test4,
588	test5,
589	};
590
591	TEST_ASSERT_VAL("No memory", evlist);
592
593	err = parse_events(evlist, "cpu-clock");
594	if (err)
595	goto out;
596
597	machines__init(&machines);
598
599	/* setup threads/dso/map/symbols also */
600	machine = setup_fake_machine(&machines);
601	if (!machine)
602	goto out;
603
604	if (verbose > 1)
605	machine__fprintf(machine, stderr);
606
607	evsel = perf_evlist__first(evlist);
608
609	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
610	err = testcases[i](evsel, machine);
611	if (err < 0)
612	break;
613	}
614
615	out:
616	/* tear down everything */
617	perf_evlist__delete(evlist);
618	machines__exit(&machines);
619
620	return err;
621	}