[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;

		TEST_ASSERT_VAL("callchains expected", !RB_EMPTY_ROOT(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_param = callchain_param_default;
	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;
347ca878 JO	219
347ca878 JO	220	TEST_ASSERT_VAL("callchains expected", !RB_EMPTY_ROOT(root));
0506aecc NK	221	cnode = rb_entry(rb_first(root), struct callchain_node, rb_node);
	222
	223	c = 0;
	224	list_for_each_entry(clist, &cnode->val, list) {
	225	scnprintf(buf, sizeof(buf), "Invalid callchain entry #%zd/%zd", i, c);
	226
	227	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	228	c < expected_callchain[i].nr);
	229	TEST_ASSERT_VAL(buf,
	230	!strcmp(CDSO(clist), expected_callchain[i].node[c].dso) &&
	231	!strcmp(CSYM(clist), expected_callchain[i].node[c].sym));
	232	c++;
	233	}
	234	/* TODO: handle multiple child nodes properly */
	235	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	236	c <= expected_callchain[i].nr);
	237	}
	238	TEST_ASSERT_VAL("Incorrect number of hist entry",
	239	i == nr_expected);
	240	TEST_ASSERT_VAL("Incorrect number of callchain entry",
	241	!symbol_conf.use_callchain \|\| nr_expected == nr_callchain);
	242	return 0;
	243	}
	244
	245	/* NO callchain + NO children */
	246	static int test1(struct perf_evsel evsel, struct machine machine)
	247	{
	248	int err;
4ea062ed	249	struct hists *hists = evsel__hists(evsel);
0506aecc NK	250	/*
	251	* expected output:
	252	*
	253	* Overhead Command Shared Object Symbol
	254	* ======== ======= ============= ==============
	255	* 20.00% perf perf [.] main
	256	* 10.00% bash [kernel] [k] page_fault
	257	* 10.00% bash bash [.] main
	258	* 10.00% bash bash [.] xmalloc
	259	* 10.00% perf [kernel] [k] page_fault
	260	* 10.00% perf [kernel] [k] schedule
	261	* 10.00% perf libc [.] free
	262	* 10.00% perf libc [.] malloc
	263	* 10.00% perf perf [.] cmd_record
	264	*/
	265	struct result expected[] = {
	266	{ 0, 2000, "perf", "perf", "main" },
	267	{ 0, 1000, "bash", "[kernel]", "page_fault" },
	268	{ 0, 1000, "bash", "bash", "main" },
	269	{ 0, 1000, "bash", "bash", "xmalloc" },
	270	{ 0, 1000, "perf", "[kernel]", "page_fault" },
	271	{ 0, 1000, "perf", "[kernel]", "schedule" },
	272	{ 0, 1000, "perf", "libc", "free" },
	273	{ 0, 1000, "perf", "libc", "malloc" },
	274	{ 0, 1000, "perf", "perf", "cmd_record" },
	275	};
	276
	277	symbol_conf.use_callchain = false;
	278	symbol_conf.cumulate_callchain = false;
f9db0d0f	279	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
0506aecc	280
40184c46	281	setup_sorting(NULL);
0506aecc NK	282	callchain_register_param(&callchain_param);
	283
	284	err = add_hist_entries(hists, machine);
	285	if (err < 0)
	286	goto out;
	287
	288	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
	289
	290	out:
	291	del_hist_entries(hists);
	292	reset_output_field();
	293	return err;
	294	}
	295
	296	/* callcain + NO children */
	297	static int test2(struct perf_evsel evsel, struct machine machine)
	298	{
	299	int err;
4ea062ed	300	struct hists *hists = evsel__hists(evsel);
0506aecc NK	301	/*
	302	* expected output:
	303	*
	304	* Overhead Command Shared Object Symbol
	305	* ======== ======= ============= ==============
	306	* 20.00% perf perf [.] main
	307	* \|
	308	* --- main
	309	*
	310	* 10.00% bash [kernel] [k] page_fault
	311	* \|
	312	* --- page_fault
	313	* malloc
	314	* main
	315	*
	316	* 10.00% bash bash [.] main
	317	* \|
	318	* --- main
	319	*
	320	* 10.00% bash bash [.] xmalloc
	321	* \|
	322	* --- xmalloc
	323	* malloc
	324	* xmalloc <--- NOTE: there's a cycle
	325	* malloc
	326	* xmalloc
	327	* main
	328	*
	329	* 10.00% perf [kernel] [k] page_fault
	330	* \|
	331	* --- page_fault
	332	* sys_perf_event_open
	333	* run_command
	334	* main
	335	*
	336	* 10.00% perf [kernel] [k] schedule
	337	* \|
	338	* --- schedule
	339	* run_command
	340	* main
	341	*
	342	* 10.00% perf libc [.] free
	343	* \|
	344	* --- free
	345	* cmd_record
	346	* run_command
	347	* main
	348	*
	349	* 10.00% perf libc [.] malloc
	350	* \|
	351	* --- malloc
	352	* cmd_record
	353	* run_command
	354	* main
	355	*
	356	* 10.00% perf perf [.] cmd_record
	357	* \|
	358	* --- cmd_record
	359	* run_command
	360	* main
	361	*
	362	*/
	363	struct result expected[] = {
	364	{ 0, 2000, "perf", "perf", "main" },
365	{ 0, 1000, "bash", "[kernel]", "page_fault" },
366	{ 0, 1000, "bash", "bash", "main" },
367	{ 0, 1000, "bash", "bash", "xmalloc" },
368	{ 0, 1000, "perf", "[kernel]", "page_fault" },
369	{ 0, 1000, "perf", "[kernel]", "schedule" },
370	{ 0, 1000, "perf", "libc", "free" },
371	{ 0, 1000, "perf", "libc", "malloc" },
372	{ 0, 1000, "perf", "perf", "cmd_record" },
373	};
374	struct callchain_result expected_callchain[] = {
375	{
376	1, { { "perf", "main" }, },
377	},
378	{
379	3, { { "[kernel]", "page_fault" },
380	{ "libc", "malloc" },
381	{ "bash", "main" }, },
382	},
383	{
384	1, { { "bash", "main" }, },
385	},
386	{
387	6, { { "bash", "xmalloc" },
388	{ "libc", "malloc" },
389	{ "bash", "xmalloc" },
390	{ "libc", "malloc" },
391	{ "bash", "xmalloc" },
392	{ "bash", "main" }, },
393	},
394	{
395	4, { { "[kernel]", "page_fault" },
396	{ "[kernel]", "sys_perf_event_open" },
397	{ "perf", "run_command" },
398	{ "perf", "main" }, },
399	},
400	{
401	3, { { "[kernel]", "schedule" },
402	{ "perf", "run_command" },
403	{ "perf", "main" }, },
404	},
405	{
406	4, { { "libc", "free" },
407	{ "perf", "cmd_record" },
408	{ "perf", "run_command" },
409	{ "perf", "main" }, },
410	},
411	{
412	4, { { "libc", "malloc" },
413	{ "perf", "cmd_record" },
414	{ "perf", "run_command" },
415	{ "perf", "main" }, },
416	},
417	{
418	3, { { "perf", "cmd_record" },
419	{ "perf", "run_command" },
420	{ "perf", "main" }, },
421	},
422	};
423
424	symbol_conf.use_callchain = true;
425	symbol_conf.cumulate_callchain = false;
f9db0d0f	426	perf_evsel__set_sample_bit(evsel, CALLCHAIN);
0506aecc	427
40184c46	428	setup_sorting(NULL);
0506aecc NK	429	callchain_register_param(&callchain_param);
	430
	431	err = add_hist_entries(hists, machine);
	432	if (err < 0)
	433	goto out;
	434
	435	err = do_test(hists, expected, ARRAY_SIZE(expected),
	436	expected_callchain, ARRAY_SIZE(expected_callchain));
	437
	438	out:
	439	del_hist_entries(hists);
	440	reset_output_field();
	441	return err;
	442	}
	443
	444	/* NO callchain + children */
	445	static int test3(struct perf_evsel evsel, struct machine machine)
	446	{
	447	int err;
4ea062ed	448	struct hists *hists = evsel__hists(evsel);
0506aecc NK	449	/*
	450	* expected output:
	451	*
	452	* Children Self Command Shared Object Symbol
	453	* ======== ======== ======= ============= =======================
	454	* 70.00% 20.00% perf perf [.] main
	455	* 50.00% 0.00% perf perf [.] run_command
	456	* 30.00% 10.00% bash bash [.] main
	457	* 30.00% 10.00% perf perf [.] cmd_record
	458	* 20.00% 0.00% bash libc [.] malloc
	459	* 10.00% 10.00% bash [kernel] [k] page_fault
5ca82710	460	* 10.00% 10.00% bash bash [.] xmalloc
0506aecc	461	* 10.00% 10.00% perf [kernel] [k] page_fault
0506aecc	462	* 10.00% 10.00% perf libc [.] malloc
5ca82710 NK	463	* 10.00% 10.00% perf [kernel] [k] schedule
	464	* 10.00% 10.00% perf libc [.] free
	465	* 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
0506aecc NK	466	*/
	467	struct result expected[] = {
	468	{ 7000, 2000, "perf", "perf", "main" },
	469	{ 5000, 0, "perf", "perf", "run_command" },
	470	{ 3000, 1000, "bash", "bash", "main" },
	471	{ 3000, 1000, "perf", "perf", "cmd_record" },
	472	{ 2000, 0, "bash", "libc", "malloc" },
	473	{ 1000, 1000, "bash", "[kernel]", "page_fault" },
5ca82710	474	{ 1000, 1000, "bash", "bash", "xmalloc" },
0506aecc	475	{ 1000, 1000, "perf", "[kernel]", "page_fault" },
5ca82710	476	{ 1000, 1000, "perf", "[kernel]", "schedule" },
0506aecc NK	477	{ 1000, 1000, "perf", "libc", "free" },
0506aecc NK	478	{ 1000, 1000, "perf", "libc", "malloc" },
5ca82710	479	{ 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
0506aecc NK	480	};
	481
	482	symbol_conf.use_callchain = false;
	483	symbol_conf.cumulate_callchain = true;
f9db0d0f	484	perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
0506aecc	485
40184c46	486	setup_sorting(NULL);
0506aecc NK	487	callchain_register_param(&callchain_param);
	488
	489	err = add_hist_entries(hists, machine);
	490	if (err < 0)
	491	goto out;
	492
	493	err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
	494
	495	out:
	496	del_hist_entries(hists);
	497	reset_output_field();
	498	return err;
	499	}
	500
	501	/* callchain + children */
	502	static int test4(struct perf_evsel evsel, struct machine machine)
	503	{
	504	int err;
4ea062ed	505	struct hists *hists = evsel__hists(evsel);
0506aecc NK	506	/*
	507	* expected output:
	508	*
	509	* Children Self Command Shared Object Symbol
	510	* ======== ======== ======= ============= =======================
	511	* 70.00% 20.00% perf perf [.] main
	512	* \|
	513	* --- main
	514	*
	515	* 50.00% 0.00% perf perf [.] run_command
	516	* \|
	517	* --- run_command
	518	* main
	519	*
	520	* 30.00% 10.00% bash bash [.] main
	521	* \|
	522	* --- main
	523	*
	524	* 30.00% 10.00% perf perf [.] cmd_record
	525	* \|
	526	* --- cmd_record
	527	* run_command
	528	* main
	529	*
	530	* 20.00% 0.00% bash libc [.] malloc
	531	* \|
	532	* --- malloc
	533	* \|
	534	* \|--50.00%-- xmalloc
	535	* \| main
	536	* --50.00%-- main
	537	*
	538	* 10.00% 10.00% bash [kernel] [k] page_fault
	539	* \|
	540	* --- page_fault
	541	* malloc
	542	* main
	543	*
5ca82710	544	* 10.00% 10.00% bash bash [.] xmalloc
0506aecc	545	* \|
5ca82710 NK	546	* --- xmalloc
	547	* malloc
	548	* xmalloc <--- NOTE: there's a cycle
	549	* malloc
	550	* xmalloc
0506aecc NK	551	* main
	552	*
	553	* 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
	554	* \|
	555	* --- sys_perf_event_open
	556	* run_command
	557	* main
	558	*
	559	* 10.00% 10.00% perf [kernel] [k] page_fault
	560	* \|
	561	* --- page_fault
	562	* sys_perf_event_open
	563	* run_command
	564	* main
	565	*
5ca82710 NK	566	* 10.00% 10.00% perf [kernel] [k] schedule
	567	* \|
	568	* --- schedule
	569	* run_command
	570	* main
	571	*
0506aecc NK	572	* 10.00% 10.00% perf libc [.] free
	573	* \|
	574	* --- free
	575	* cmd_record
	576	* run_command
	577	* main
	578	*
	579	* 10.00% 10.00% perf libc [.] malloc
	580	* \|
	581	* --- malloc
	582	* cmd_record
	583	* run_command
	584	* main
	585	*
0506aecc NK	586	*/
	587	struct result expected[] = {
	588	{ 7000, 2000, "perf", "perf", "main" },
	589	{ 5000, 0, "perf", "perf", "run_command" },
	590	{ 3000, 1000, "bash", "bash", "main" },
	591	{ 3000, 1000, "perf", "perf", "cmd_record" },
	592	{ 2000, 0, "bash", "libc", "malloc" },
	593	{ 1000, 1000, "bash", "[kernel]", "page_fault" },
5ca82710	594	{ 1000, 1000, "bash", "bash", "xmalloc" },
0506aecc NK	595	{ 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
0506aecc NK	596	{ 1000, 1000, "perf", "[kernel]", "page_fault" },
5ca82710	597	{ 1000, 1000, "perf", "[kernel]", "schedule" },
0506aecc NK	598	{ 1000, 1000, "perf", "libc", "free" },
0506aecc NK	599	{ 1000, 1000, "perf", "libc", "malloc" },
0506aecc NK	600	};
	601	struct callchain_result expected_callchain[] = {
	602	{
	603	1, { { "perf", "main" }, },
	604	},
	605	{
	606	2, { { "perf", "run_command" },
	607	{ "perf", "main" }, },
	608	},
	609	{
	610	1, { { "bash", "main" }, },
	611	},
	612	{
	613	3, { { "perf", "cmd_record" },
	614	{ "perf", "run_command" },
	615	{ "perf", "main" }, },
	616	},
	617	{
	618	4, { { "libc", "malloc" },
	619	{ "bash", "xmalloc" },
	620	{ "bash", "main" },
	621	{ "bash", "main" }, },
	622	},
	623	{
	624	3, { { "[kernel]", "page_fault" },
	625	{ "libc", "malloc" },
	626	{ "bash", "main" }, },
	627	},
	628	{
5ca82710 NK	629	6, { { "bash", "xmalloc" },
	630	{ "libc", "malloc" },
	631	{ "bash", "xmalloc" },
	632	{ "libc", "malloc" },
	633	{ "bash", "xmalloc" },
	634	{ "bash", "main" }, },
0506aecc NK	635	},
	636	{
	637	3, { { "[kernel]", "sys_perf_event_open" },
	638	{ "perf", "run_command" },
	639	{ "perf", "main" }, },
	640	},
	641	{
	642	4, { { "[kernel]", "page_fault" },
	643	{ "[kernel]", "sys_perf_event_open" },
	644	{ "perf", "run_command" },
	645	{ "perf", "main" }, },
	646	},
5ca82710 NK	647	{
	648	3, { { "[kernel]", "schedule" },
	649	{ "perf", "run_command" },
	650	{ "perf", "main" }, },
	651	},
0506aecc NK	652	{
	653	4, { { "libc", "free" },
	654	{ "perf", "cmd_record" },
	655	{ "perf", "run_command" },
	656	{ "perf", "main" }, },
	657	},
	658	{
	659	4, { { "libc", "malloc" },
	660	{ "perf", "cmd_record" },
	661	{ "perf", "run_command" },
	662	{ "perf", "main" }, },
	663	},
0506aecc NK	664	};
	665
	666	symbol_conf.use_callchain = true;
	667	symbol_conf.cumulate_callchain = true;
f9db0d0f	668	perf_evsel__set_sample_bit(evsel, CALLCHAIN);
0506aecc	669
40184c46	670	setup_sorting(NULL);
347ca878 JO	671
347ca878 JO	672	callchain_param = callchain_param_default;
0506aecc NK	673	callchain_register_param(&callchain_param);
	674
	675	err = add_hist_entries(hists, machine);
	676	if (err < 0)
	677	goto out;
	678
	679	err = do_test(hists, expected, ARRAY_SIZE(expected),
	680	expected_callchain, ARRAY_SIZE(expected_callchain));
	681
	682	out:
	683	del_hist_entries(hists);
	684	reset_output_field();
	685	return err;
	686	}
	687
721a1f53	688	int test__hists_cumulate(int subtest __maybe_unused)
0506aecc NK	689	{
	690	int err = TEST_FAIL;
	691	struct machines machines;
	692	struct machine *machine;
	693	struct perf_evsel *evsel;
	694	struct perf_evlist *evlist = perf_evlist__new();
	695	size_t i;
	696	test_fn_t testcases[] = {
	697	test1,
	698	test2,
	699	test3,
	700	test4,
	701	};
	702
	703	TEST_ASSERT_VAL("No memory", evlist);
	704
b39b8393	705	err = parse_events(evlist, "cpu-clock", NULL);
0506aecc NK	706	if (err)
0506aecc NK	707	goto out;
b0500c16	708	err = TEST_FAIL;
0506aecc NK	709
	710	machines__init(&machines);
	711
	712	/* setup threads/dso/map/symbols also */
	713	machine = setup_fake_machine(&machines);
	714	if (!machine)
	715	goto out;
	716
	717	if (verbose > 1)
	718	machine__fprintf(machine, stderr);
	719
	720	evsel = perf_evlist__first(evlist);
	721
	722	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
	723	err = testcases[i](evsel, machine);
	724	if (err < 0)
	725	break;
	726	}
	727
	728	out:
	729	/* tear down everything */
	730	perf_evlist__delete(evlist);
	731	machines__exit(&machines);
	732
	733	return err;
	734	}