Commit a7d945bc authored by Namhyung Kim's avatar Namhyung Kim Committed by Jiri Olsa
Browse files

perf report: Add -F option to specify output fields 



The -F/--fields option is to allow user setup output field in any
order.  It can receive any sort keys and following (hpp) fields:

  overhead, overhead_sys, overhead_us, sample and period

If guest profiling is enabled, overhead_guest_{sys,us} will be
available too.

The output fields also affect sort order unless you give -s/--sort
option.  And any keys specified on -s option, will also be added to
the output field list automatically.

  $ perf report -F sym,sample,overhead
  ...
  #                     Symbol       Samples  Overhead
  # ..........................  ............  ........
  #
    [.] __cxa_atexit                       2     2.50%
    [.] __libc_csu_init                    4     5.00%
    [.] __new_exitfn                       3     3.75%
    [.] _dl_check_map_versions             1     1.25%
    [.] _dl_name_match_p                   4     5.00%
    [.] _dl_setup_hash                     1     1.25%
    [.] _dl_sysdep_start                   1     1.25%
    [.] _init                              5     6.25%
    [.] _setjmp                            6     7.50%
    [.] a                                  8    10.00%
    [.] b                                  8    10.00%
    [.] brk                                1     1.25%
    [.] c                                  8    10.00%

Note that, the example output above is captured after applying next
patch which fixes sort/comparing behavior.

Requested-by: default avatarIngo Molnar <mingo@kernel.org>
Signed-off-by: default avatarNamhyung Kim <namhyung@kernel.org>
Acked-by: default avatarIngo Molnar <mingo@kernel.org>
Link: http://lkml.kernel.org/r/1400480762-22852-12-git-send-email-namhyung@kernel.org


Signed-off-by: default avatarJiri Olsa <jolsa@kernel.org>
parent 22af969e

tools/perf/Documentation/perf-report.txt

+10 −0
Original line number Diff line number Diff line
@@ -107,6 +107,16 @@ OPTIONS 
	And default sort keys are changed to comm, dso_from, symbol_from, dso_to

	and symbol_to, see '--branch-stack'.



-F::

--fields=::

	Specify output field - multiple keys can be specified in CSV format.

	Following fields are available:

	overhead, overhead_sys, overhead_us, sample and period.

	Also it can contain any sort key(s).



	By default, every sort keys not specified in -F will be appended

	automatically.



-p::

--parent=<regex>::

        A regex filter to identify parent. The parent is a caller of this

tools/perf/builtin-report.c

+7 −8
Original line number Diff line number Diff line
@@ -701,6 +701,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) 
	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",

		   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."

		   " Please refer the man page for the complete list."),

	OPT_STRING('F', "fields", &field_order, "key[,keys...]",

		   "output field(s): overhead, period, sample plus all of sort keys"),

	OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,

		    "Show sample percentage for different cpu modes"),

	OPT_STRING('p', "parent", &parent_pattern, "regex",
@@ -814,17 +816,14 @@ repeat: 
	}



	if (setup_sorting() < 0) {

		if (sort_order)

			parse_options_usage(report_usage, options, "s", 1);

		if (field_order)

			parse_options_usage(sort_order ? NULL : report_usage,

					    options, "F", 1);

		goto error;

	}



	if (parent_pattern != default_parent_pattern) {

		if (sort_dimension__add("parent") < 0)

			goto error;

	}



	perf_hpp__init();



	/* Force tty output for header output. */

	if (report.header || report.header_only)

		use_browser = 0;

tools/perf/ui/hist.c

+55 −4
Original line number Diff line number Diff line
@@ -355,6 +355,12 @@ void perf_hpp__init(void) 
			INIT_LIST_HEAD(&fmt->sort_list);

	}



	/*

	 * If user specified field order, no need to setup default fields.

	 */

	if (field_order)

		return;



	perf_hpp__column_enable(PERF_HPP__OVERHEAD);



	if (symbol_conf.show_cpu_utilization) {
@@ -377,8 +383,6 @@ void perf_hpp__init(void) 
	list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list;

	if (list_empty(list))

		list_add(list, &perf_hpp__sort_list);



	perf_hpp__setup_output_field();

}



void perf_hpp__column_register(struct perf_hpp_fmt *format)
@@ -403,8 +407,55 @@ void perf_hpp__setup_output_field(void) 


	/* append sort keys to output field */

	perf_hpp__for_each_sort_list(fmt) {

		if (list_empty(&fmt->list))

		if (!list_empty(&fmt->list))

			continue;



		/*

		 * sort entry fields are dynamically created,

		 * so they can share a same sort key even though

		 * the list is empty.

		 */

		if (perf_hpp__is_sort_entry(fmt)) {

			struct perf_hpp_fmt *pos;



			perf_hpp__for_each_format(pos) {

				if (perf_hpp__same_sort_entry(pos, fmt))

					goto next;

			}

		}



		perf_hpp__column_register(fmt);

next:

		continue;

	}

}



void perf_hpp__append_sort_keys(void)

{

	struct perf_hpp_fmt *fmt;



	/* append output fields to sort keys */

	perf_hpp__for_each_format(fmt) {

		if (!list_empty(&fmt->sort_list))

			continue;



		/*

		 * sort entry fields are dynamically created,

		 * so they can share a same sort key even though

		 * the list is empty.

		 */

		if (perf_hpp__is_sort_entry(fmt)) {

			struct perf_hpp_fmt *pos;



			perf_hpp__for_each_sort_list(pos) {

				if (perf_hpp__same_sort_entry(pos, fmt))

					goto next;

			}

		}



		perf_hpp__register_sort_field(fmt);

next:

		continue;

	}

}

tools/perf/util/hist.h

+4 −0
Original line number Diff line number Diff line
@@ -197,6 +197,10 @@ void perf_hpp__column_register(struct perf_hpp_fmt *format); 
void perf_hpp__column_enable(unsigned col);

void perf_hpp__register_sort_field(struct perf_hpp_fmt *format);

void perf_hpp__setup_output_field(void);

void perf_hpp__append_sort_keys(void);



bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format);

bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b);



typedef u64 (*hpp_field_fn)(struct hist_entry *he);

typedef int (*hpp_callback_fn)(struct perf_hpp *hpp, bool front);

tools/perf/util/sort.c

+204 −5
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso 
const char	default_top_sort_order[] = "dso,symbol";

const char	default_diff_sort_order[] = "dso,symbol";

const char	*sort_order;

const char	*field_order;

regex_t		ignore_callees_regex;

int		have_ignore_callees = 0;

int		sort__need_collapse = 0;
@@ -1057,6 +1058,20 @@ struct hpp_sort_entry { 
	struct sort_entry *se;

};



bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)

{

	struct hpp_sort_entry *hse_a;

	struct hpp_sort_entry *hse_b;



	if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))

		return false;



	hse_a = container_of(a, struct hpp_sort_entry, hpp);

	hse_b = container_of(b, struct hpp_sort_entry, hpp);



	return hse_a->se == hse_b->se;

}



static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,

			      struct perf_evsel *evsel)

{
@@ -1092,14 +1107,15 @@ static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 
	return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);

}



static int __sort_dimension__add_hpp(struct sort_dimension *sd)

static struct hpp_sort_entry *

__sort_dimension__alloc_hpp(struct sort_dimension *sd)

{

	struct hpp_sort_entry *hse;



	hse = malloc(sizeof(*hse));

	if (hse == NULL) {

		pr_err("Memory allocation failed\n");

		return -1;

		return NULL;

	}



	hse->se = sd->entry;
@@ -1115,16 +1131,42 @@ static int __sort_dimension__add_hpp(struct sort_dimension *sd) 
	INIT_LIST_HEAD(&hse->hpp.list);

	INIT_LIST_HEAD(&hse->hpp.sort_list);



	return hse;

}



bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)

{

	return format->header == __sort__hpp_header;

}



static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)

{

	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);



	if (hse == NULL)

		return -1;



	perf_hpp__register_sort_field(&hse->hpp);

	return 0;

}



static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)

{

	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);



	if (hse == NULL)

		return -1;



	perf_hpp__column_register(&hse->hpp);

	return 0;

}



static int __sort_dimension__add(struct sort_dimension *sd, enum sort_type idx)

{

	if (sd->taken)

		return 0;



	if (__sort_dimension__add_hpp(sd) < 0)

	if (__sort_dimension__add_hpp_sort(sd) < 0)

		return -1;



	if (sd->entry->se_collapse)
@@ -1149,6 +1191,28 @@ static int __hpp_dimension__add(struct hpp_dimension *hd) 
	return 0;

}



static int __sort_dimension__add_output(struct sort_dimension *sd)

{

	if (sd->taken)

		return 0;



	if (__sort_dimension__add_hpp_output(sd) < 0)

		return -1;



	sd->taken = 1;

	return 0;

}



static int __hpp_dimension__add_output(struct hpp_dimension *hd)

{

	if (!hd->taken) {

		hd->taken = 1;



		perf_hpp__column_register(hd->fmt);

	}

	return 0;

}



int sort_dimension__add(const char *tok)

{

	unsigned int i;
@@ -1237,14 +1301,23 @@ static const char *get_default_sort_order(void) 
	return default_sort_orders[sort__mode];

}



int setup_sorting(void)

static int __setup_sorting(void)

{

	char *tmp, *tok, *str;

	const char *sort_keys = sort_order;

	int ret = 0;



	if (sort_keys == NULL)

	if (sort_keys == NULL) {

		if (field_order) {

			/*

			 * If user specified field order but no sort order,

			 * we'll honor it and not add default sort orders.

			 */

			return 0;

		}



		sort_keys = get_default_sort_order();

	}



	str = strdup(sort_keys);

	if (str == NULL) {
@@ -1331,3 +1404,129 @@ void sort__setup_elide(FILE *output) 
	list_for_each_entry(se, &hist_entry__sort_list, list)

		se->elide = false;

}



static int output_field_add(char *tok)

{

	unsigned int i;



	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {

		struct sort_dimension *sd = &common_sort_dimensions[i];



		if (strncasecmp(tok, sd->name, strlen(tok)))

			continue;



		return __sort_dimension__add_output(sd);

	}



	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {

		struct hpp_dimension *hd = &hpp_sort_dimensions[i];



		if (strncasecmp(tok, hd->name, strlen(tok)))

			continue;



		return __hpp_dimension__add_output(hd);

	}



	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {

		struct sort_dimension *sd = &bstack_sort_dimensions[i];



		if (strncasecmp(tok, sd->name, strlen(tok)))

			continue;



		return __sort_dimension__add_output(sd);

	}



	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {

		struct sort_dimension *sd = &memory_sort_dimensions[i];



		if (strncasecmp(tok, sd->name, strlen(tok)))

			continue;



		return __sort_dimension__add_output(sd);

	}



	return -ESRCH;

}



static void reset_dimensions(void)

{

	unsigned int i;



	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)

		common_sort_dimensions[i].taken = 0;



	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)

		hpp_sort_dimensions[i].taken = 0;



	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)

		bstack_sort_dimensions[i].taken = 0;



	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)

		memory_sort_dimensions[i].taken = 0;

}



static int __setup_output_field(void)

{

	char *tmp, *tok, *str;

	int ret = 0;



	if (field_order == NULL)

		return 0;



	reset_dimensions();



	str = strdup(field_order);

	if (str == NULL) {

		error("Not enough memory to setup output fields");

		return -ENOMEM;

	}



	for (tok = strtok_r(str, ", ", &tmp);

			tok; tok = strtok_r(NULL, ", ", &tmp)) {

		ret = output_field_add(tok);

		if (ret == -EINVAL) {

			error("Invalid --fields key: `%s'", tok);

			break;

		} else if (ret == -ESRCH) {

			error("Unknown --fields key: `%s'", tok);

			break;

		}

	}



	free(str);

	return ret;

}



int setup_sorting(void)

{

	int err;



	err = __setup_sorting();

	if (err < 0)

		return err;



	if (parent_pattern != default_parent_pattern) {

		err = sort_dimension__add("parent");

		if (err < 0)

			return err;

	}



	reset_dimensions();



	/*

	 * perf diff doesn't use default hpp output fields.

	 */

	if (sort__mode != SORT_MODE__DIFF)

		perf_hpp__init();



	err = __setup_output_field();

	if (err < 0)

		return err;



	/* copy sort keys to output fields */

	perf_hpp__setup_output_field();

	/* and then copy output fields to sort keys */

	perf_hpp__append_sort_keys();



	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE