[linux-block.git] / tools / perf / tests / hists_cumulate.c

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