Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4157922a authored by Ingo Molnar's avatar Ingo Molnar Committed by Arnaldo Carvalho de Melo
Browse files

perf bench: Change the procps visible command-name of invididual benchmark tests plus cleanups 



Before this patch, looking at 'perf bench sched pipe' behavior over
'top' only told us that something related to perf is running:

      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
    19934 mingo     20   0 54836 1296  952 R 18.6  0.0   0:00.56 perf
    19935 mingo     20   0 54836  384   36 S 18.6  0.0   0:00.56 perf

After the patch it's clearly visible what's going on:

      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
    19744 mingo     20   0  125m 3536 2644 R 68.2  0.0   0:01.12 sched-pipe
    19745 mingo     20   0  125m 1172  276 R 68.2  0.0   0:01.12 sched-pipe

The benchmark-subsystem name is concatenated with the individual
testcase name.

Unfortunately 'perf top' does not show the reconfigured name, possibly
because it caches ->comm[] values and does not recognize changes to
them?

Also clean up a few bits in builtin-bench.c while at it and reorganize
the code and the output strings to be consistent.

Use iterators to access the various arrays. Rename 'suites' concept to
'benchmark collection' and the 'bench_suite' to 'benchmark/bench'. The
many repetitions of 'suite' made the code harder to read and understand.

The new output is:

  comet:~/tip/tools/perf> ./perf bench
  Usage:
        perf bench [<common options>] <collection> <benchmark> [<options>]

        # List of all available benchmark collections:

         sched: Scheduler and IPC benchmarks
           mem: Memory access benchmarks
          numa: NUMA scheduling and MM benchmarks
           all: All benchmarks

  comet:~/tip/tools/perf> ./perf bench sched

        # List of available benchmarks for collection 'sched':

     messaging: Benchmark for scheduling and IPC
          pipe: Benchmark for pipe() between two processes
           all: Test all scheduler benchmarks

  comet:~/tip/tools/perf> ./perf bench mem

        # List of available benchmarks for collection 'mem':

        memcpy: Benchmark for memcpy()
        memset: Benchmark for memset() tests
           all: Test all memory benchmarks

  comet:~/tip/tools/perf> ./perf bench numa

        # List of available benchmarks for collection 'numa':

           mem: Benchmark for NUMA workloads
           all: Test all NUMA benchmarks

Individual benchmark modules were not touched.

Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <h.mitake@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung.kim@lge.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20131023123756.GA17871@gmail.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 3d918a12

tools/perf/builtin-bench.c

+122 −117
Original line number Diff line number Diff line 
/*

 *

 * builtin-bench.c

 *

 * General benchmarking subsystem provided by perf

 * General benchmarking collections provided by perf

 *

 * Copyright (C) 2009, Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>

 *

 */



/*

 * Available benchmark collection list:

 *

 * Available subsystem list:

 *  sched ... scheduler and IPC mechanism

 *  sched ... scheduler and IPC performance

 *  mem   ... memory access performance

 *

 *  numa  ... NUMA scheduling and MM performance

 */



#include "perf.h"

#include "util/util.h"

#include "util/parse-options.h"
@@ -25,112 +22,92 @@ 
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/prctl.h>



struct bench_suite {

typedef int (*bench_fn_t)(int argc, const char **argv, const char *prefix);



struct bench {

	const char	*name;

	const char	*summary;

	int (*fn)(int, const char **, const char *);

	bench_fn_t	fn;

};

						\

/* sentinel: easy for help */

#define suite_all { "all", "Test all benchmark suites", NULL }



#ifdef HAVE_LIBNUMA_SUPPORT

static struct bench_suite numa_suites[] = {

	{ "mem",

	  "Benchmark for NUMA workloads",

	  bench_numa },

	suite_all,

	{ NULL,

	  NULL,

	  NULL                  }

static struct bench numa_benchmarks[] = {

	{ "mem",	"Benchmark for NUMA workloads",			bench_numa		},

	{ "all",	"Test all NUMA benchmarks",			NULL			},

	{ NULL,		NULL,						NULL			}

};

#endif



static struct bench_suite sched_suites[] = {

	{ "messaging",

	  "Benchmark for scheduler and IPC mechanisms",

	  bench_sched_messaging },

	{ "pipe",

	  "Flood of communication over pipe() between two processes",

	  bench_sched_pipe      },

	suite_all,

	{ NULL,

	  NULL,

	  NULL                  }

static struct bench sched_benchmarks[] = {

	{ "messaging",	"Benchmark for scheduling and IPC",		bench_sched_messaging	},

	{ "pipe",	"Benchmark for pipe() between two processes",	bench_sched_pipe	},

	{ "all",	"Test all scheduler benchmarks",		NULL			},

	{ NULL,		NULL,						NULL			}

};



static struct bench_suite mem_suites[] = {

	{ "memcpy",

	  "Simple memory copy in various ways",

	  bench_mem_memcpy },

	{ "memset",

	  "Simple memory set in various ways",

	  bench_mem_memset },

	suite_all,

	{ NULL,

	  NULL,

	  NULL             }

static struct bench mem_benchmarks[] = {

	{ "memcpy",	"Benchmark for memcpy()",			bench_mem_memcpy	},

	{ "memset",	"Benchmark for memset() tests",			bench_mem_memset	},

	{ "all",	"Test all memory benchmarks",			NULL			},

	{ NULL,		NULL,						NULL			}

};



struct bench_subsys {

struct collection {

	const char	*name;

	const char	*summary;

	struct bench_suite *suites;

	struct bench	*benchmarks;

};



static struct bench_subsys subsystems[] = {

static struct collection collections[] = {

	{ "sched",	"Scheduler and IPC benchmarks",		sched_benchmarks	},

	{ "mem",	"Memory access benchmarks",			mem_benchmarks		},

#ifdef HAVE_LIBNUMA_SUPPORT

	{ "numa",

	  "NUMA scheduling and MM behavior",

	  numa_suites },

	{ "numa",	"NUMA scheduling and MM benchmarks",		numa_benchmarks		},

#endif

	{ "sched",

	  "scheduler and IPC mechanism",

	  sched_suites },

	{ "mem",

	  "memory access performance",

	  mem_suites },

	{ "all",		/* sentinel: easy for help */

	  "all benchmark subsystem",

	  NULL },

	{ NULL,

	  NULL,

	  NULL       }

	{ "all",	"All benchmarks",				NULL			},

	{ NULL,		NULL,						NULL			}

};



static void dump_suites(int subsys_index)

/* Iterate over all benchmark collections: */

#define for_each_collection(coll) \

	for (coll = collections; coll->name; coll++)



/* Iterate over all benchmarks within a collection: */

#define for_each_bench(coll, bench) \

	for (bench = coll->benchmarks; bench->name; bench++)



static void dump_benchmarks(struct collection *coll)

{

	int i;

	struct bench *bench;



	printf("# List of available suites for %s...\n\n",

	       subsystems[subsys_index].name);

	printf("\n        # List of available benchmarks for collection '%s':\n\n", coll->name);



	for (i = 0; subsystems[subsys_index].suites[i].name; i++)

		printf("%14s: %s\n",

		       subsystems[subsys_index].suites[i].name,

		       subsystems[subsys_index].suites[i].summary);

	for_each_bench(coll, bench)

		printf("%14s: %s\n", bench->name, bench->summary);



	printf("\n");

	return;

}



static const char *bench_format_str;



/* Output/formatting style, exported to benchmark modules: */

int bench_format = BENCH_FORMAT_DEFAULT;



static const struct option bench_options[] = {

	OPT_STRING('f', "format", &bench_format_str, "default",

		    "Specify format style"),

	OPT_STRING('f', "format", &bench_format_str, "default", "Specify format style"),

	OPT_END()

};



static const char * const bench_usage[] = {

	"perf bench [<common options>] <subsystem> <suite> [<options>]",

	"perf bench [<common options>] <collection> <benchmark> [<options>]",

	NULL

};



static void print_usage(void)

{

	struct collection *coll;

	int i;



	printf("Usage: \n");
@@ -138,11 +115,10 @@ static void print_usage(void) 
		printf("\t%s\n", bench_usage[i]);

	printf("\n");



	printf("# List of available subsystems...\n\n");

	printf("        # List of all available benchmark collections:\n\n");



	for (i = 0; subsystems[i].name; i++)

		printf("%14s: %s\n",

		       subsystems[i].name, subsystems[i].summary);

	for_each_collection(coll)

		printf("%14s: %s\n", coll->name, coll->summary);

	printf("\n");

}
@@ -159,44 +135,74 @@ static int bench_str2int(const char *str) 
	return BENCH_FORMAT_UNKNOWN;

}



static void all_suite(struct bench_subsys *subsys)	  /* FROM HERE */

/*

 * Run a specific benchmark but first rename the running task's ->comm[]

 * to something meaningful:

 */

static int run_bench(const char *coll_name, const char *bench_name, bench_fn_t fn,

		     int argc, const char **argv, const char *prefix)

{

	int i;

	int size;

	char *name;

	int ret;



	size = strlen(coll_name) + 1 + strlen(bench_name) + 1;



	name = zalloc(size);

	BUG_ON(!name);



	scnprintf(name, size, "%s-%s", coll_name, bench_name);



	prctl(PR_SET_NAME, name);

	argv[0] = name;



	ret = fn(argc, argv, prefix);



	free(name);



	return ret;

}



static void run_collection(struct collection *coll)

{

	struct bench *bench;

	const char *argv[2];

	struct bench_suite *suites = subsys->suites;



	argv[1] = NULL;

	/*

	 * TODO:

	 * preparing preset parameters for

	 *

	 * Preparing preset parameters for

	 * embedded, ordinary PC, HPC, etc...

	 * will be helpful

	 * would be helpful.

	 */

	for (i = 0; suites[i].fn; i++) {

		printf("# Running %s/%s benchmark...\n",

		       subsys->name,

		       suites[i].name);

	for_each_bench(coll, bench) {

		if (!bench->fn)

			break;

		printf("# Running %s/%s benchmark...\n", coll->name, bench->name);

		fflush(stdout);



		argv[1] = suites[i].name;

		suites[i].fn(1, argv, NULL);

		argv[1] = bench->name;

		run_bench(coll->name, bench->name, bench->fn, 1, argv, NULL);

		printf("\n");

	}

}



static void all_subsystem(void)

static void run_all_collections(void)

{

	int i;

	for (i = 0; subsystems[i].suites; i++)

		all_suite(&subsystems[i]);

	struct collection *coll;



	for_each_collection(coll)

		run_collection(coll);

}



int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused)

{

	int i, j, status = 0;

	struct collection *coll;

	int ret = 0;



	if (argc < 2) {

		/* No subsystem specified. */

		/* No collection specified. */

		print_usage();

		goto end;

	}
@@ -206,7 +212,7 @@ int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused) 


	bench_format = bench_str2int(bench_format_str);

	if (bench_format == BENCH_FORMAT_UNKNOWN) {

		printf("Unknown format descriptor:%s\n", bench_format_str);

		printf("Unknown format descriptor: '%s'\n", bench_format_str);

		goto end;

	}
@@ -216,52 +222,51 @@ int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused) 
	}



	if (!strcmp(argv[0], "all")) {

		all_subsystem();

		run_all_collections();

		goto end;

	}



	for (i = 0; subsystems[i].name; i++) {

		if (strcmp(subsystems[i].name, argv[0]))

	for_each_collection(coll) {

		struct bench *bench;



		if (strcmp(coll->name, argv[0]))

			continue;



		if (argc < 2) {

			/* No suite specified. */

			dump_suites(i);

			/* No bench specified. */

			dump_benchmarks(coll);

			goto end;

		}



		if (!strcmp(argv[1], "all")) {

			all_suite(&subsystems[i]);

			run_collection(coll);

			goto end;

		}



		for (j = 0; subsystems[i].suites[j].name; j++) {

			if (strcmp(subsystems[i].suites[j].name, argv[1]))

		for_each_bench(coll, bench) {

			if (strcmp(bench->name, argv[1]))

				continue;



			if (bench_format == BENCH_FORMAT_DEFAULT)

				printf("# Running %s/%s benchmark...\n",

				       subsystems[i].name,

				       subsystems[i].suites[j].name);

				printf("# Running '%s/%s' benchmark:\n", coll->name, bench->name);

			fflush(stdout);

			status = subsystems[i].suites[j].fn(argc - 1,

							    argv + 1, prefix);

			ret = run_bench(coll->name, bench->name, bench->fn, argc-1, argv+1, prefix);

			goto end;

		}



		if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {

			dump_suites(i);

			dump_benchmarks(coll);

			goto end;

		}



		printf("Unknown suite:%s for %s\n", argv[1], argv[0]);

		status = 1;

		printf("Unknown benchmark: '%s' for collection '%s'\n", argv[1], argv[0]);

		ret = 1;

		goto end;

	}



	printf("Unknown subsystem:%s\n", argv[0]);

	status = 1;

	printf("Unknown collection: '%s'\n", argv[0]);

	ret = 1;



end:

	return status;

	return ret;

}