[deliverable/linux.git] / tools / perf / tests / hists_cumulate.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 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() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
	/* perf [perf]   main() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [perf]   cmd_record() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
	/* perf [libc]   malloc() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
	/* perf [libc]   free() */
	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
	/* perf [perf]   main() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
	/* perf [kernel] page_fault() */
	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	/* bash [bash]   main() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_MAIN, },
	/* bash [bash]   xmalloc() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_BASH_XMALLOC, },
	/* bash [kernel] page_fault() */
	{ .pid = FAKE_PID_BASH,  .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
};

/*
 * Will be casted to struct ip_callchain which has all 64 bit entries
 * of nr and ips[].
 */
static u64 fake_callchains[][10] = {
	/*   schedule => run_command => main */
	{ 3, FAKE_IP_KERNEL_SCHEDULE, FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
	/*   main  */
	{ 1, FAKE_IP_PERF_MAIN, },
	/*   cmd_record => run_command => main */
	{ 3, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
	/*   malloc => cmd_record => run_command => main */
	{ 4, FAKE_IP_LIBC_MALLOC, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND,
	     FAKE_IP_PERF_MAIN, },
	/*   free => cmd_record => run_command => main */
	{ 4, FAKE_IP_LIBC_FREE, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND,
	     FAKE_IP_PERF_MAIN, },
	/*   main */
	{ 1, FAKE_IP_PERF_MAIN, },
	/*   page_fault => sys_perf_event_open => run_command => main */
	{ 4, FAKE_IP_KERNEL_PAGE_FAULT, FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN,
	     FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
	/*   main */
	{ 1, FAKE_IP_BASH_MAIN, },
	/*   xmalloc => malloc => xmalloc => malloc => xmalloc => main */
	{ 6, FAKE_IP_BASH_XMALLOC, FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_XMALLOC,
	     FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_XMALLOC, FAKE_IP_BASH_MAIN, },
	/*   page_fault => malloc => main */
	{ 3, FAKE_IP_KERNEL_PAGE_FAULT, FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_MAIN, },
};

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 = 1000, };
	size_t i;

	for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
		struct hist_entry_iter iter = {
			.evsel = evsel,
			.sample	= &sample,
			.hide_unresolved = false,
		};

		if (symbol_conf.cumulate_callchain)
			iter.ops = &hist_iter_cumulative;
		else
			iter.ops = &hist_iter_normal;

		sample.cpumode = PERF_RECORD_MISC_USER;
		sample.pid = fake_samples[i].pid;
		sample.tid = fake_samples[i].pid;
		sample.ip = fake_samples[i].ip;
		sample.callchain = (struct ip_callchain *)fake_callchains[i];

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

		if (hist_entry_iter__add(&iter, &al, sysctl_perf_event_max_stack,
					 NULL) < 0) {
			addr_location__put(&al);
			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 (hists__has(hists, 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__delete(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)
#define DEPTH(he) (he->callchain->max_depth)
#define CDSO(cl)  (cl->ms.map->dso->short_name)
#define CSYM(cl)  (cl->ms.sym->name)

struct result {
	u64 children;
	u64 self;
	const char *comm;
	const char *dso;
	const char *sym;
};

struct callchain_result {
	u64 nr;
	struct {
		const char *dso;
		const char *sym;
	} node[10];
};

static int do_test(struct hists *hists, struct result *expected, size_t nr_expected,
		   struct callchain_result *expected_callchain, size_t nr_callchain)
{
	char buf[32];
	size_t i, c;
	struct hist_entry *he;
	struct rb_root *root;
	struct rb_node *node;
	struct callchain_node *cnode;
	struct callchain_list *clist;

	/*
	 * adding and deleting hist entries must be done outside of this
	 * function since TEST_ASSERT_VAL() returns in case of failure.
	 */
	hists__collapse_resort(hists, NULL);
	perf_evsel__output_resort(hists_to_evsel(hists), NULL);

	if (verbose > 2) {
		pr_info("use callchain: %d, cumulate callchain: %d\n",
			symbol_conf.use_callchain,
			symbol_conf.cumulate_callchain);
		print_hists_out(hists);
	}

	root = &hists->entries;
	for (node = rb_first(root), i = 0;
	     node && (he = rb_entry(node, struct hist_entry, rb_node));
	     node = rb_next(node), i++) {
		scnprintf(buf, sizeof(buf), "Invalid hist entry #%zd", i);

		TEST_ASSERT_VAL("Incorrect number of hist entry",
				i < nr_expected);
		TEST_ASSERT_VAL(buf, he->stat.period == expected[i].self &&
				!strcmp(COMM(he), expected[i].comm) &&
				!strcmp(DSO(he), expected[i].dso) &&
				!strcmp(SYM(he), expected[i].sym));

		if (symbol_conf.cumulate_callchain)
			TEST_ASSERT_VAL(buf, he->stat_acc->period == expected[i].children);

		if (!symbol_conf.use_callchain)
			continue;

		/* check callchain entries */
		root = &he->callchain->node.rb_root;
		cnode = rb_entry(rb_first(root), struct callchain_node, rb_node);

		c = 0;
		list_for_each_entry(clist, &cnode->val, list) {
			scnprintf(buf, sizeof(buf), "Invalid callchain entry #%zd/%zd", i, c);

			TEST_ASSERT_VAL("Incorrect number of callchain entry",
					c < expected_callchain[i].nr);
			TEST_ASSERT_VAL(buf,
				!strcmp(CDSO(clist), expected_callchain[i].node[c].dso) &&
				!strcmp(CSYM(clist), expected_callchain[i].node[c].sym));
			c++;
		}
		/* TODO: handle multiple child nodes properly */
		TEST_ASSERT_VAL("Incorrect number of callchain entry",
				c <= expected_callchain[i].nr);
	}
	TEST_ASSERT_VAL("Incorrect number of hist entry",
			i == nr_expected);
	TEST_ASSERT_VAL("Incorrect number of callchain entry",
			!symbol_conf.use_callchain || nr_expected == nr_callchain);
	return 0;
}

/* NO callchain + NO children */
static int test1(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = evsel__hists(evsel);
	/*
	 * 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
	 */
	struct result expected[] = {
		{ 0, 2000, "perf", "perf",     "main" },
		{ 0, 1000, "bash", "[kernel]", "page_fault" },
		{ 0, 1000, "bash", "bash",     "main" },
		{ 0, 1000, "bash", "bash",     "xmalloc" },
		{ 0, 1000, "perf", "[kernel]", "page_fault" },
		{ 0, 1000, "perf", "[kernel]", "schedule" },
		{ 0, 1000, "perf", "libc",     "free" },
		{ 0, 1000, "perf", "libc",     "malloc" },
		{ 0, 1000, "perf", "perf",     "cmd_record" },
	};

	symbol_conf.use_callchain = false;
	symbol_conf.cumulate_callchain = false;
	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);

	setup_sorting(NULL);
	callchain_register_param(&callchain_param);

	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);

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

/* callcain + NO children */
static int test2(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = evsel__hists(evsel);
	/*
	 * expected output:
	 *
	 * Overhead  Command  Shared Object          Symbol
	 * ========  =======  =============  ==============
	 *   20.00%     perf  perf           [.] main
	 *              |
	 *              --- main
	 *
	 *   10.00%     bash  [kernel]       [k] page_fault
	 *              |
	 *              --- page_fault
	 *                  malloc
	 *                  main
	 *
	 *   10.00%     bash  bash           [.] main
	 *              |
	 *              --- main
	 *
	 *   10.00%     bash  bash           [.] xmalloc
	 *              |
	 *              --- xmalloc
	 *                  malloc
	 *                  xmalloc     <--- NOTE: there's a cycle
	 *                  malloc
	 *                  xmalloc
	 *                  main
	 *
	 *   10.00%     perf  [kernel]       [k] page_fault
	 *              |
	 *              --- page_fault
	 *                  sys_perf_event_open
	 *                  run_command
	 *                  main
	 *
	 *   10.00%     perf  [kernel]       [k] schedule
	 *              |
	 *              --- schedule
	 *                  run_command
	 *                  main
	 *
	 *   10.00%     perf  libc           [.] free
	 *              |
	 *              --- free
	 *                  cmd_record
	 *                  run_command
	 *                  main
	 *
	 *   10.00%     perf  libc           [.] malloc
	 *              |
	 *              --- malloc
	 *                  cmd_record
	 *                  run_command
	 *                  main
	 *
	 *   10.00%     perf  perf           [.] cmd_record
	 *              |
	 *              --- cmd_record
	 *                  run_command
	 *                  main
	 *
	 */
	struct result expected[] = {
		{ 0, 2000, "perf", "perf",     "main" },
		{ 0, 1000, "bash", "[kernel]", "page_fault" },
		{ 0, 1000, "bash", "bash",     "main" },
		{ 0, 1000, "bash", "bash",     "xmalloc" },
		{ 0, 1000, "perf", "[kernel]", "page_fault" },
		{ 0, 1000, "perf", "[kernel]", "schedule" },
		{ 0, 1000, "perf", "libc",     "free" },
		{ 0, 1000, "perf", "libc",     "malloc" },
		{ 0, 1000, "perf", "perf",     "cmd_record" },
	};
	struct callchain_result expected_callchain[] = {
		{
			1, {	{ "perf",     "main" }, },
		},
		{
			3, {	{ "[kernel]", "page_fault" },
				{ "libc",     "malloc" },
				{ "bash",     "main" }, },
		},
		{
			1, {	{ "bash",     "main" }, },
		},
		{
			6, {	{ "bash",     "xmalloc" },
				{ "libc",     "malloc" },
				{ "bash",     "xmalloc" },
				{ "libc",     "malloc" },
				{ "bash",     "xmalloc" },
				{ "bash",     "main" }, },
		},
		{
			4, {	{ "[kernel]", "page_fault" },
				{ "[kernel]", "sys_perf_event_open" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			3, {	{ "[kernel]", "schedule" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "libc",     "free" },
				{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "libc",     "malloc" },
				{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			3, {	{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
	};

	symbol_conf.use_callchain = true;
	symbol_conf.cumulate_callchain = false;
	perf_evsel__set_sample_bit(evsel, CALLCHAIN);

	setup_sorting(NULL);
	callchain_register_param(&callchain_param);

	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	err = do_test(hists, expected, ARRAY_SIZE(expected),
		      expected_callchain, ARRAY_SIZE(expected_callchain));

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

/* NO callchain + children */
static int test3(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = evsel__hists(evsel);
	/*
	 * expected output:
	 *
	 * Children      Self  Command  Shared Object                   Symbol
	 * ========  ========  =======  =============  =======================
	 *   70.00%    20.00%     perf  perf           [.] main
	 *   50.00%     0.00%     perf  perf           [.] run_command
	 *   30.00%    10.00%     bash  bash           [.] main
	 *   30.00%    10.00%     perf  perf           [.] cmd_record
	 *   20.00%     0.00%     bash  libc           [.] malloc
	 *   10.00%    10.00%     bash  [kernel]       [k] page_fault
	 *   10.00%    10.00%     bash  bash           [.] xmalloc
	 *   10.00%    10.00%     perf  [kernel]       [k] page_fault
	 *   10.00%    10.00%     perf  libc           [.] malloc
	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
	 *   10.00%    10.00%     perf  libc           [.] free
	 *   10.00%     0.00%     perf  [kernel]       [k] sys_perf_event_open
	 */
	struct result expected[] = {
		{ 7000, 2000, "perf", "perf",     "main" },
		{ 5000,    0, "perf", "perf",     "run_command" },
		{ 3000, 1000, "bash", "bash",     "main" },
		{ 3000, 1000, "perf", "perf",     "cmd_record" },
		{ 2000,    0, "bash", "libc",     "malloc" },
		{ 1000, 1000, "bash", "[kernel]", "page_fault" },
		{ 1000, 1000, "bash", "bash",     "xmalloc" },
		{ 1000, 1000, "perf", "[kernel]", "page_fault" },
		{ 1000, 1000, "perf", "[kernel]", "schedule" },
		{ 1000, 1000, "perf", "libc",     "free" },
		{ 1000, 1000, "perf", "libc",     "malloc" },
		{ 1000,    0, "perf", "[kernel]", "sys_perf_event_open" },
	};

	symbol_conf.use_callchain = false;
	symbol_conf.cumulate_callchain = true;
	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);

	setup_sorting(NULL);
	callchain_register_param(&callchain_param);

	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);

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

/* callchain + children */
static int test4(struct perf_evsel *evsel, struct machine *machine)
{
	int err;
	struct hists *hists = evsel__hists(evsel);
	/*
	 * expected output:
	 *
	 * Children      Self  Command  Shared Object                   Symbol
	 * ========  ========  =======  =============  =======================
	 *   70.00%    20.00%     perf  perf           [.] main
	 *              |
	 *              --- main
	 *
	 *   50.00%     0.00%     perf  perf           [.] run_command
	 *              |
	 *              --- run_command
	 *                  main
	 *
	 *   30.00%    10.00%     bash  bash           [.] main
	 *              |
	 *              --- main
	 *
	 *   30.00%    10.00%     perf  perf           [.] cmd_record
	 *              |
	 *              --- cmd_record
	 *                  run_command
	 *                  main
	 *
	 *   20.00%     0.00%     bash  libc           [.] malloc
	 *              |
	 *              --- malloc
	 *                 |
	 *                 |--50.00%-- xmalloc
	 *                 |           main
	 *                  --50.00%-- main
	 *
	 *   10.00%    10.00%     bash  [kernel]       [k] page_fault
	 *              |
	 *              --- page_fault
	 *                  malloc
	 *                  main
	 *
	 *   10.00%    10.00%     bash  bash           [.] xmalloc
	 *              |
	 *              --- xmalloc
	 *                  malloc
	 *                  xmalloc     <--- NOTE: there's a cycle
	 *                  malloc
	 *                  xmalloc
	 *                  main
	 *
	 *   10.00%     0.00%     perf  [kernel]       [k] sys_perf_event_open
	 *              |
	 *              --- sys_perf_event_open
	 *                  run_command
	 *                  main
	 *
	 *   10.00%    10.00%     perf  [kernel]       [k] page_fault
	 *              |
	 *              --- page_fault
	 *                  sys_perf_event_open
	 *                  run_command
	 *                  main
	 *
	 *   10.00%    10.00%     perf  [kernel]       [k] schedule
	 *              |
	 *              --- schedule
	 *                  run_command
	 *                  main
	 *
	 *   10.00%    10.00%     perf  libc           [.] free
	 *              |
	 *              --- free
	 *                  cmd_record
	 *                  run_command
	 *                  main
	 *
	 *   10.00%    10.00%     perf  libc           [.] malloc
	 *              |
	 *              --- malloc
	 *                  cmd_record
	 *                  run_command
	 *                  main
	 *
	 */
	struct result expected[] = {
		{ 7000, 2000, "perf", "perf",     "main" },
		{ 5000,    0, "perf", "perf",     "run_command" },
		{ 3000, 1000, "bash", "bash",     "main" },
		{ 3000, 1000, "perf", "perf",     "cmd_record" },
		{ 2000,    0, "bash", "libc",     "malloc" },
		{ 1000, 1000, "bash", "[kernel]", "page_fault" },
		{ 1000, 1000, "bash", "bash",     "xmalloc" },
		{ 1000,    0, "perf", "[kernel]", "sys_perf_event_open" },
		{ 1000, 1000, "perf", "[kernel]", "page_fault" },
		{ 1000, 1000, "perf", "[kernel]", "schedule" },
		{ 1000, 1000, "perf", "libc",     "free" },
		{ 1000, 1000, "perf", "libc",     "malloc" },
	};
	struct callchain_result expected_callchain[] = {
		{
			1, {	{ "perf",     "main" }, },
		},
		{
			2, {	{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			1, {	{ "bash",     "main" }, },
		},
		{
			3, {	{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "libc",     "malloc" },
				{ "bash",     "xmalloc" },
				{ "bash",     "main" },
				{ "bash",     "main" }, },
		},
		{
			3, {	{ "[kernel]", "page_fault" },
				{ "libc",     "malloc" },
				{ "bash",     "main" }, },
		},
		{
			6, {	{ "bash",     "xmalloc" },
				{ "libc",     "malloc" },
				{ "bash",     "xmalloc" },
				{ "libc",     "malloc" },
				{ "bash",     "xmalloc" },
				{ "bash",     "main" }, },
		},
		{
			3, {	{ "[kernel]", "sys_perf_event_open" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "[kernel]", "page_fault" },
				{ "[kernel]", "sys_perf_event_open" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			3, {	{ "[kernel]", "schedule" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "libc",     "free" },
				{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
		{
			4, {	{ "libc",     "malloc" },
				{ "perf",     "cmd_record" },
				{ "perf",     "run_command" },
				{ "perf",     "main" }, },
		},
	};

	symbol_conf.use_callchain = true;
	symbol_conf.cumulate_callchain = true;
	perf_evsel__set_sample_bit(evsel, CALLCHAIN);

	setup_sorting(NULL);
	callchain_register_param(&callchain_param);

	err = add_hist_entries(hists, machine);
	if (err < 0)
		goto out;

	err = do_test(hists, expected, ARRAY_SIZE(expected),
		      expected_callchain, ARRAY_SIZE(expected_callchain));

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

int test__hists_cumulate(int subtest __maybe_unused)
{
	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,
	};

	TEST_ASSERT_VAL("No memory", evlist);

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

	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
0506aecc 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 pid;
	15	u64 ip;
	16	struct thread *thread;
	17	struct map *map;
	18	struct symbol *sym;
	19	};
	20
	21	/* For the numbers, see hists_common.c */
	22	static struct sample fake_samples[] = {
	23	/* perf [kernel] schedule() */
	24	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, },
	25	/* perf [perf] main() */
	26	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
	27	/* perf [perf] cmd_record() */
	28	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
	29	/* perf [libc] malloc() */
	30	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
	31	/* perf [libc] free() */
	32	{ .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
	33	/* perf [perf] main() */
	34	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
	35	/* perf [kernel] page_fault() */
	36	{ .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	37	/* bash [bash] main() */
	38	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_MAIN, },
	39	/* bash [bash] xmalloc() */
	40	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, },
	41	/* bash [kernel] page_fault() */
	42	{ .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
	43	};
	44
	45	/*
	46	* Will be casted to struct ip_callchain which has all 64 bit entries
	47	* of nr and ips[].
	48	*/
	49	static u64 fake_callchains[][10] = {
	50	/* schedule => run_command => main */
	51	{ 3, FAKE_IP_KERNEL_SCHEDULE, FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
	52	/* main */
	53	{ 1, FAKE_IP_PERF_MAIN, },
	54	/* cmd_record => run_command => main */
	55	{ 3, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
	56	/* malloc => cmd_record => run_command => main */
	57	{ 4, FAKE_IP_LIBC_MALLOC, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND,
	58	FAKE_IP_PERF_MAIN, },
	59	/* free => cmd_record => run_command => main */
	60	{ 4, FAKE_IP_LIBC_FREE, FAKE_IP_PERF_CMD_RECORD, FAKE_IP_PERF_RUN_COMMAND,
	61	FAKE_IP_PERF_MAIN, },
	62	/* main */
	63	{ 1, FAKE_IP_PERF_MAIN, },
	64	/* page_fault => sys_perf_event_open => run_command => main */
65	{ 4, FAKE_IP_KERNEL_PAGE_FAULT, FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN,
66	FAKE_IP_PERF_RUN_COMMAND, FAKE_IP_PERF_MAIN, },
67	/* main */
68	{ 1, FAKE_IP_BASH_MAIN, },
69	/* xmalloc => malloc => xmalloc => malloc => xmalloc => main */
70	{ 6, FAKE_IP_BASH_XMALLOC, FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_XMALLOC,
71	FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_XMALLOC, FAKE_IP_BASH_MAIN, },
72	/* page_fault => malloc => main */
73	{ 3, FAKE_IP_KERNEL_PAGE_FAULT, FAKE_IP_LIBC_MALLOC, FAKE_IP_BASH_MAIN, },
74	};
75
76	static int add_hist_entries(struct hists hists, struct machine machine)
77	{
78	struct addr_location al;
79	struct perf_evsel *evsel = hists_to_evsel(hists);
80	struct perf_sample sample = { .period = 1000, };
81	size_t i;
82
83	for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
0506aecc	84	struct hist_entry_iter iter = {
063bd936 NK	85	.evsel = evsel,
063bd936 NK	86	.sample = &sample,
0506aecc NK	87	.hide_unresolved = false,
	88	};
	89
	90	if (symbol_conf.cumulate_callchain)
	91	iter.ops = &hist_iter_cumulative;
	92	else
	93	iter.ops = &hist_iter_normal;
	94
473398a2	95	sample.cpumode = PERF_RECORD_MISC_USER;
0506aecc NK	96	sample.pid = fake_samples[i].pid;
	97	sample.tid = fake_samples[i].pid;
	98	sample.ip = fake_samples[i].ip;
	99	sample.callchain = (struct ip_callchain *)fake_callchains[i];
	100
bb3eb566	101	if (machine__resolve(machine, &al, &sample) < 0)
0506aecc NK	102	goto out;
0506aecc NK	103
4cb93446	104	if (hist_entry_iter__add(&iter, &al, sysctl_perf_event_max_stack,
063bd936	105	NULL) < 0) {
b91fc39f	106	addr_location__put(&al);
0506aecc	107	goto out;
b91fc39f	108	}
0506aecc NK	109
	110	fake_samples[i].thread = al.thread;
	111	fake_samples[i].map = al.map;
	112	fake_samples[i].sym = al.sym;
	113	}
	114
	115	return TEST_OK;
	116
	117	out:
	118	pr_debug("Not enough memory for adding a hist entry\n");
	119	return TEST_FAIL;
	120	}
	121
	122	static void del_hist_entries(struct hists *hists)
	123	{
	124	struct hist_entry *he;
	125	struct rb_root *root_in;
	126	struct rb_root *root_out;
	127	struct rb_node *node;
	128
52225036	129	if (hists__has(hists, need_collapse))
0506aecc NK	130	root_in = &hists->entries_collapsed;
	131	else
	132	root_in = hists->entries_in;
	133
	134	root_out = &hists->entries;
	135
	136	while (!RB_EMPTY_ROOT(root_out)) {
	137	node = rb_first(root_out);
	138
	139	he = rb_entry(node, struct hist_entry, rb_node);
	140	rb_erase(node, root_out);
	141	rb_erase(&he->rb_node_in, root_in);
6733d1bf	142	hist_entry__delete(he);
0506aecc NK	143	}
	144	}
	145
	146	typedef int (test_fn_t)(struct perf_evsel , struct machine *);
	147
	148	#define COMM(he) (thread__comm_str(he->thread))
	149	#define DSO(he) (he->ms.map->dso->short_name)
	150	#define SYM(he) (he->ms.sym->name)
	151	#define CPU(he) (he->cpu)
	152	#define PID(he) (he->thread->tid)
	153	#define DEPTH(he) (he->callchain->max_depth)
	154	#define CDSO(cl) (cl->ms.map->dso->short_name)
	155	#define CSYM(cl) (cl->ms.sym->name)
	156
	157	struct result {
	158	u64 children;
	159	u64 self;
	160	const char *comm;
	161	const char *dso;
	162	const char *sym;
	163	};
	164
	165	struct callchain_result {
	166	u64 nr;
	167	struct {
	168	const char *dso;
	169	const char *sym;
	170	} node[10];
	171	};
	172
	173	static int do_test(struct hists hists, struct result expected, size_t nr_expected,
	174	struct callchain_result *expected_callchain, size_t nr_callchain)
	175	{
	176	char buf[32];
	177	size_t i, c;
	178	struct hist_entry *he;
	179	struct rb_root *root;
	180	struct rb_node *node;
	181	struct callchain_node *cnode;
	182	struct callchain_list *clist;
	183
	184	/*
	185	* adding and deleting hist entries must be done outside of this
	186	* function since TEST_ASSERT_VAL() returns in case of failure.
	187	*/
	188	hists__collapse_resort(hists, NULL);
452ce03b	189	perf_evsel__output_resort(hists_to_evsel(hists), NULL);
0506aecc NK	190
	191	if (verbose > 2) {
	192	pr_info("use callchain: %d, cumulate callchain: %d\n",
	193	symbol_conf.use_callchain,
	194	symbol_conf.cumulate_callchain);
	195	print_hists_out(hists);
	196	}
	197
	198	root = &hists->entries;
	199	for (node = rb_first(root), i = 0;
	200	node && (he = rb_entry(node, struct hist_entry, rb_node));
	201	node = rb_next(node), i++) {
	202	scnprintf(buf, sizeof(buf), "Invalid hist entry #%zd", i);
	203
	204	TEST_ASSERT_VAL("Incorrect number of hist entry",
	205	i < nr_expected);
	206	TEST_ASSERT_VAL(buf, he->stat.period == expected[i].self &&
	207	!strcmp(COMM(he), expected[i].comm) &&
	208	!strcmp(DSO(he), expected[i].dso) &&
	209	!strcmp(SYM(he), expected[i].sym));
	210
	211	if (symbol_conf.cumulate_callchain)
	212	TEST_ASSERT_VAL(buf, he->stat_acc->period == expected[i].children);
	213
	214	if (!symbol_conf.use_callchain)
	215	continue;
	216
	217	/* check callchain entries */
	218	root = &he->callchain->node.rb_root;
	219	cnode = rb_entry(rb_first(root), struct callchain_node, rb_node);
	220
	221	c = 0;
	222	list_for_each_entry(clist, &cnode->val, list) {
	223	scnprintf(buf, sizeof(buf), "Invalid callchain entry #%zd/%zd", i, c);
	224
	225	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	226	c < expected_callchain[i].nr);
	227	TEST_ASSERT_VAL(buf,
	228	!strcmp(CDSO(clist), expected_callchain[i].node[c].dso) &&
	229	!strcmp(CSYM(clist), expected_callchain[i].node[c].sym));
	230	c++;
	231	}
	232	/* TODO: handle multiple child nodes properly */
	233	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	234	c <= expected_callchain[i].nr);
	235	}
	236	TEST_ASSERT_VAL("Incorrect number of hist entry",
	237	i == nr_expected);
	238	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	239	!symbol_conf.use_callchain \|\| nr_expected == nr_callchain);
	240	return 0;
	241	}
	242
	243	/* NO callchain + NO children */
	244	static int test1(struct perf_evsel evsel, struct machine machine)
	245	{
	246	int err;
4ea062ed	247	struct hists *hists = evsel__hists(evsel);
0506aecc NK	248	/*
	249	* expected output:
	250	*
	251	* Overhead Command Shared Object Symbol
	252	* ======== ======= ============= ==============
	253	* 20.00% perf perf [.] main
	254	* 10.00% bash [kernel] [k] page_fault
	255	* 10.00% bash bash [.] main
	256	* 10.00% bash bash [.] xmalloc
	257	* 10.00% perf [kernel] [k] page_fault
	258	* 10.00% perf [kernel] [k] schedule
	259	* 10.00% perf libc [.] free
	260	* 10.00% perf libc [.] malloc
	261	* 10.00% perf perf [.] cmd_record
	262	*/
	263	struct result expected[] = {
	264	{ 0, 2000, "perf", "perf", "main" },
	265	{ 0, 1000, "bash", "[kernel]", "page_fault" },
	266	{ 0, 1000, "bash", "bash", "main" },
	267	{ 0, 1000, "bash", "bash", "xmalloc" },
	268	{ 0, 1000, "perf", "[kernel]", "page_fault" },
	269	{ 0, 1000, "perf", "[kernel]", "schedule" },
	270	{ 0, 1000, "perf", "libc", "free" },
	271	{ 0, 1000, "perf", "libc", "malloc" },
	272	{ 0, 1000, "perf", "perf", "cmd_record" },
	273	};
	274
	275	symbol_conf.use_callchain = false;
	276	symbol_conf.cumulate_callchain = false;
f9db0d0f	277	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
0506aecc	278
40184c46	279	setup_sorting(NULL);
0506aecc NK	280	callchain_register_param(&callchain_param);
	281
	282	err = add_hist_entries(hists, machine);
	283	if (err < 0)
	284	goto out;
	285
	286	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
	287
	288	out:
	289	del_hist_entries(hists);
	290	reset_output_field();
	291	return err;
	292	}
	293
	294	/* callcain + NO children */
	295	static int test2(struct perf_evsel evsel, struct machine machine)
	296	{
	297	int err;
4ea062ed	298	struct hists *hists = evsel__hists(evsel);
0506aecc NK	299	/*
	300	* expected output:
	301	*
	302	* Overhead Command Shared Object Symbol
	303	* ======== ======= ============= ==============
	304	* 20.00% perf perf [.] main
	305	* \|
	306	* --- main
	307	*
	308	* 10.00% bash [kernel] [k] page_fault
	309	* \|
	310	* --- page_fault
	311	* malloc
	312	* main
	313	*
	314	* 10.00% bash bash [.] main
	315	* \|
	316	* --- main
	317	*
	318	* 10.00% bash bash [.] xmalloc
	319	* \|
	320	* --- xmalloc
	321	* malloc
	322	* xmalloc <--- NOTE: there's a cycle
	323	* malloc
	324	* xmalloc
	325	* main
	326	*
	327	* 10.00% perf [kernel] [k] page_fault
	328	* \|
	329	* --- page_fault
	330	* sys_perf_event_open
	331	* run_command
	332	* main
	333	*
	334	* 10.00% perf [kernel] [k] schedule
	335	* \|
	336	* --- schedule
	337	* run_command
	338	* main
	339	*
	340	* 10.00% perf libc [.] free
	341	* \|
	342	* --- free
	343	* cmd_record
	344	* run_command
	345	* main
	346	*
	347	* 10.00% perf libc [.] malloc
	348	* \|
	349	* --- malloc
	350	* cmd_record
	351	* run_command
	352	* main
	353	*
	354	* 10.00% perf perf [.] cmd_record
	355	* \|
	356	* --- cmd_record
	357	* run_command
	358	* main
	359	*
	360	*/
	361	struct result expected[] = {
	362	{ 0, 2000, "perf", "perf", "main" },
363	{ 0, 1000, "bash", "[kernel]", "page_fault" },
364	{ 0, 1000, "bash", "bash", "main" },
365	{ 0, 1000, "bash", "bash", "xmalloc" },
366	{ 0, 1000, "perf", "[kernel]", "page_fault" },
367	{ 0, 1000, "perf", "[kernel]", "schedule" },
368	{ 0, 1000, "perf", "libc", "free" },
369	{ 0, 1000, "perf", "libc", "malloc" },
370	{ 0, 1000, "perf", "perf", "cmd_record" },
371	};
372	struct callchain_result expected_callchain[] = {
373	{
374	1, { { "perf", "main" }, },
375	},
376	{
377	3, { { "[kernel]", "page_fault" },
378	{ "libc", "malloc" },
379	{ "bash", "main" }, },
380	},
381	{
382	1, { { "bash", "main" }, },
383	},
384	{
385	6, { { "bash", "xmalloc" },
386	{ "libc", "malloc" },
387	{ "bash", "xmalloc" },
388	{ "libc", "malloc" },
389	{ "bash", "xmalloc" },
390	{ "bash", "main" }, },
391	},
392	{
393	4, { { "[kernel]", "page_fault" },
394	{ "[kernel]", "sys_perf_event_open" },
395	{ "perf", "run_command" },
396	{ "perf", "main" }, },
397	},
398	{
399	3, { { "[kernel]", "schedule" },
400	{ "perf", "run_command" },
401	{ "perf", "main" }, },
402	},
403	{
404	4, { { "libc", "free" },
405	{ "perf", "cmd_record" },
406	{ "perf", "run_command" },
407	{ "perf", "main" }, },
408	},
409	{
410	4, { { "libc", "malloc" },
411	{ "perf", "cmd_record" },
412	{ "perf", "run_command" },
413	{ "perf", "main" }, },
414	},
415	{
416	3, { { "perf", "cmd_record" },
417	{ "perf", "run_command" },
418	{ "perf", "main" }, },
419	},
420	};
421
422	symbol_conf.use_callchain = true;
423	symbol_conf.cumulate_callchain = false;
f9db0d0f	424	perf_evsel__set_sample_bit(evsel, CALLCHAIN);
0506aecc	425
40184c46	426	setup_sorting(NULL);
0506aecc NK	427	callchain_register_param(&callchain_param);
	428
	429	err = add_hist_entries(hists, machine);
	430	if (err < 0)
	431	goto out;
	432
	433	err = do_test(hists, expected, ARRAY_SIZE(expected),
	434	expected_callchain, ARRAY_SIZE(expected_callchain));
	435
	436	out:
	437	del_hist_entries(hists);
	438	reset_output_field();
	439	return err;
	440	}
	441
	442	/* NO callchain + children */
	443	static int test3(struct perf_evsel evsel, struct machine machine)
	444	{
	445	int err;
4ea062ed	446	struct hists *hists = evsel__hists(evsel);
0506aecc NK	447	/*
	448	* expected output:
	449	*
	450	* Children Self Command Shared Object Symbol
	451	* ======== ======== ======= ============= =======================
	452	* 70.00% 20.00% perf perf [.] main
	453	* 50.00% 0.00% perf perf [.] run_command
	454	* 30.00% 10.00% bash bash [.] main
	455	* 30.00% 10.00% perf perf [.] cmd_record
	456	* 20.00% 0.00% bash libc [.] malloc
	457	* 10.00% 10.00% bash [kernel] [k] page_fault
5ca82710	458	* 10.00% 10.00% bash bash [.] xmalloc
0506aecc	459	* 10.00% 10.00% perf [kernel] [k] page_fault
0506aecc	460	* 10.00% 10.00% perf libc [.] malloc
5ca82710 NK	461	* 10.00% 10.00% perf [kernel] [k] schedule
	462	* 10.00% 10.00% perf libc [.] free
	463	* 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
0506aecc NK	464	*/
	465	struct result expected[] = {
	466	{ 7000, 2000, "perf", "perf", "main" },
	467	{ 5000, 0, "perf", "perf", "run_command" },
	468	{ 3000, 1000, "bash", "bash", "main" },
	469	{ 3000, 1000, "perf", "perf", "cmd_record" },
	470	{ 2000, 0, "bash", "libc", "malloc" },
	471	{ 1000, 1000, "bash", "[kernel]", "page_fault" },
5ca82710	472	{ 1000, 1000, "bash", "bash", "xmalloc" },
0506aecc	473	{ 1000, 1000, "perf", "[kernel]", "page_fault" },
5ca82710	474	{ 1000, 1000, "perf", "[kernel]", "schedule" },
0506aecc NK	475	{ 1000, 1000, "perf", "libc", "free" },
0506aecc NK	476	{ 1000, 1000, "perf", "libc", "malloc" },
5ca82710	477	{ 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
0506aecc NK	478	};
	479
	480	symbol_conf.use_callchain = false;
	481	symbol_conf.cumulate_callchain = true;
f9db0d0f	482	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
0506aecc	483
40184c46	484	setup_sorting(NULL);
0506aecc NK	485	callchain_register_param(&callchain_param);
	486
	487	err = add_hist_entries(hists, machine);
	488	if (err < 0)
	489	goto out;
	490
	491	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
	492
	493	out:
	494	del_hist_entries(hists);
	495	reset_output_field();
	496	return err;
	497	}
	498
	499	/* callchain + children */
	500	static int test4(struct perf_evsel evsel, struct machine machine)
	501	{
	502	int err;
4ea062ed	503	struct hists *hists = evsel__hists(evsel);
0506aecc NK	504	/*
	505	* expected output:
	506	*
	507	* Children Self Command Shared Object Symbol
	508	* ======== ======== ======= ============= =======================
	509	* 70.00% 20.00% perf perf [.] main
	510	* \|
	511	* --- main
	512	*
	513	* 50.00% 0.00% perf perf [.] run_command
	514	* \|
	515	* --- run_command
	516	* main
	517	*
	518	* 30.00% 10.00% bash bash [.] main
	519	* \|
	520	* --- main
	521	*
	522	* 30.00% 10.00% perf perf [.] cmd_record
	523	* \|
	524	* --- cmd_record
	525	* run_command
	526	* main
	527	*
	528	* 20.00% 0.00% bash libc [.] malloc
	529	* \|
	530	* --- malloc
	531	* \|
	532	* \|--50.00%-- xmalloc
	533	* \| main
	534	* --50.00%-- main
	535	*
	536	* 10.00% 10.00% bash [kernel] [k] page_fault
	537	* \|
	538	* --- page_fault
	539	* malloc
	540	* main
	541	*
5ca82710	542	* 10.00% 10.00% bash bash [.] xmalloc
0506aecc	543	* \|
5ca82710 NK	544	* --- xmalloc
	545	* malloc
	546	* xmalloc <--- NOTE: there's a cycle
	547	* malloc
	548	* xmalloc
0506aecc NK	549	* main
	550	*
	551	* 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
	552	* \|
	553	* --- sys_perf_event_open
	554	* run_command
	555	* main
	556	*
	557	* 10.00% 10.00% perf [kernel] [k] page_fault
	558	* \|
	559	* --- page_fault
	560	* sys_perf_event_open
	561	* run_command
	562	* main
	563	*
5ca82710 NK	564	* 10.00% 10.00% perf [kernel] [k] schedule
	565	* \|
	566	* --- schedule
	567	* run_command
	568	* main
	569	*
0506aecc NK	570	* 10.00% 10.00% perf libc [.] free
	571	* \|
	572	* --- free
	573	* cmd_record
	574	* run_command
	575	* main
	576	*
	577	* 10.00% 10.00% perf libc [.] malloc
	578	* \|
	579	* --- malloc
	580	* cmd_record
	581	* run_command
	582	* main
	583	*
0506aecc NK	584	*/
	585	struct result expected[] = {
	586	{ 7000, 2000, "perf", "perf", "main" },
	587	{ 5000, 0, "perf", "perf", "run_command" },
	588	{ 3000, 1000, "bash", "bash", "main" },
	589	{ 3000, 1000, "perf", "perf", "cmd_record" },
	590	{ 2000, 0, "bash", "libc", "malloc" },
	591	{ 1000, 1000, "bash", "[kernel]", "page_fault" },
5ca82710	592	{ 1000, 1000, "bash", "bash", "xmalloc" },
0506aecc NK	593	{ 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
0506aecc NK	594	{ 1000, 1000, "perf", "[kernel]", "page_fault" },
5ca82710	595	{ 1000, 1000, "perf", "[kernel]", "schedule" },
0506aecc NK	596	{ 1000, 1000, "perf", "libc", "free" },
0506aecc NK	597	{ 1000, 1000, "perf", "libc", "malloc" },
0506aecc NK	598	};
	599	struct callchain_result expected_callchain[] = {
	600	{
	601	1, { { "perf", "main" }, },
	602	},
	603	{
	604	2, { { "perf", "run_command" },
	605	{ "perf", "main" }, },
	606	},
	607	{
	608	1, { { "bash", "main" }, },
	609	},
	610	{
	611	3, { { "perf", "cmd_record" },
	612	{ "perf", "run_command" },
	613	{ "perf", "main" }, },
	614	},
	615	{
	616	4, { { "libc", "malloc" },
	617	{ "bash", "xmalloc" },
	618	{ "bash", "main" },
	619	{ "bash", "main" }, },
	620	},
	621	{
	622	3, { { "[kernel]", "page_fault" },
	623	{ "libc", "malloc" },
	624	{ "bash", "main" }, },
	625	},
	626	{
5ca82710 NK	627	6, { { "bash", "xmalloc" },
	628	{ "libc", "malloc" },
	629	{ "bash", "xmalloc" },
	630	{ "libc", "malloc" },
	631	{ "bash", "xmalloc" },
	632	{ "bash", "main" }, },
0506aecc NK	633	},
	634	{
	635	3, { { "[kernel]", "sys_perf_event_open" },
	636	{ "perf", "run_command" },
	637	{ "perf", "main" }, },
	638	},
	639	{
	640	4, { { "[kernel]", "page_fault" },
	641	{ "[kernel]", "sys_perf_event_open" },
	642	{ "perf", "run_command" },
	643	{ "perf", "main" }, },
	644	},
5ca82710 NK	645	{
	646	3, { { "[kernel]", "schedule" },
	647	{ "perf", "run_command" },
	648	{ "perf", "main" }, },
	649	},
0506aecc NK	650	{
	651	4, { { "libc", "free" },
	652	{ "perf", "cmd_record" },
	653	{ "perf", "run_command" },
	654	{ "perf", "main" }, },
	655	},
	656	{
	657	4, { { "libc", "malloc" },
	658	{ "perf", "cmd_record" },
	659	{ "perf", "run_command" },
	660	{ "perf", "main" }, },
	661	},
0506aecc NK	662	};
	663
	664	symbol_conf.use_callchain = true;
	665	symbol_conf.cumulate_callchain = true;
f9db0d0f	666	perf_evsel__set_sample_bit(evsel, CALLCHAIN);
0506aecc	667
40184c46	668	setup_sorting(NULL);
0506aecc NK	669	callchain_register_param(&callchain_param);
	670
	671	err = add_hist_entries(hists, machine);
	672	if (err < 0)
	673	goto out;
	674
	675	err = do_test(hists, expected, ARRAY_SIZE(expected),
	676	expected_callchain, ARRAY_SIZE(expected_callchain));
	677
	678	out:
	679	del_hist_entries(hists);
	680	reset_output_field();
	681	return err;
	682	}
	683
721a1f53	684	int test__hists_cumulate(int subtest __maybe_unused)
0506aecc NK	685	{
	686	int err = TEST_FAIL;
	687	struct machines machines;
	688	struct machine *machine;
	689	struct perf_evsel *evsel;
	690	struct perf_evlist *evlist = perf_evlist__new();
	691	size_t i;
	692	test_fn_t testcases[] = {
	693	test1,
	694	test2,
	695	test3,
	696	test4,
	697	};
	698
	699	TEST_ASSERT_VAL("No memory", evlist);
	700
b39b8393	701	err = parse_events(evlist, "cpu-clock", NULL);
0506aecc NK	702	if (err)
0506aecc NK	703	goto out;
b0500c16	704	err = TEST_FAIL;
0506aecc NK	705
	706	machines__init(&machines);
	707
	708	/* setup threads/dso/map/symbols also */
	709	machine = setup_fake_machine(&machines);
	710	if (!machine)
	711	goto out;
	712
	713	if (verbose > 1)
	714	machine__fprintf(machine, stderr);
	715
	716	evsel = perf_evlist__first(evlist);
	717
	718	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
	719	err = testcases[i](evsel, machine);
	720	if (err < 0)
	721	break;
	722	}
	723
	724	out:
	725	/* tear down everything */
	726	perf_evlist__delete(evlist);
	727	machines__exit(&machines);
	728
	729	return err;
	730	}