Eric Lee / smarc-fsl-linux-kernel

Commit e4b546a3643fbfc510d5ef7db538e4d3ab00effb

Authored by Ingo Molnar 14 years ago

Exists in master and in 39 other branches

Merge branch 'perf/core' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/l…

…inux-2.6 into perf/core

Showing 15 changed files Inline Diff

tools/perf/Documentation/perf-annotate.txt
tools/perf/Documentation/perf-buildid-list.txt
tools/perf/Documentation/perf-diff.txt
tools/perf/Documentation/perf-kvm.txt
tools/perf/Documentation/perf-lock.txt
tools/perf/Documentation/perf-probe.txt
tools/perf/Documentation/perf-record.txt
tools/perf/Documentation/perf-report.txt
tools/perf/Documentation/perf-sched.txt
tools/perf/Documentation/perf-script.txt
tools/perf/Documentation/perf-stat.txt
tools/perf/Documentation/perf-test.txt
tools/perf/Documentation/perf-top.txt
tools/perf/builtin-diff.c
tools/perf/builtin-stat.c

tools/perf/Documentation/perf-annotate.txt

Diff comments View file @ e4b546a

 perf-annotate(1)
 ================
 NAME
 ----
 perf-annotate - Read perf.data (created by perf record) and display annotated code
 SYNOPSIS
 --------
 [verse]
 'perf annotate' [-i <file> | --input=file] [symbol_name]
 DESCRIPTION
 -----------
 This command reads the input file and displays an annotated version of the
 code. If the object file has debug symbols then the source code will be
 displayed alongside assembly code.
 If there is no debug info in the object, then annotated assembly is displayed.
 OPTIONS
 -------
 -i::
 --input=::
         Input file name. (default: perf.data)
+-d::
+--dsos=<dso[,dso...]>::
+        Only consider symbols in these dsos.
+-s::
+--symbol=<symbol>::
+        Symbol to annotate.
+-f::
+--force::
+        Don't complain, do it.
+-v::
+--verbose::
+        Be more verbose. (Show symbol address, etc)
+-D::
+--dump-raw-trace::
+        Dump raw trace in ASCII.
+-k::
+--vmlinux=<file>::
+        vmlinux pathname.
+-m::
+--modules::
+        Load module symbols. WARNING: use only with -k and LIVE kernel.
+-l::
+--print-line::
+        Print matching source lines (may be slow).
+-P::
+--full-paths::
+        Don't shorten the displayed pathnames.
 --stdio:: Use the stdio interface.
 --tui:: Use the TUI interface Use of --tui requires a tty, if one is not
 	present, as when piping to other commands, the stdio interface is
 	used. This interfaces starts by centering on the line with more
-	samples, TAB/UNTAB cycles thru the lines with more samples.
+	samples, TAB/UNTAB cycles through the lines with more samples.
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-report[1]

tools/perf/Documentation/perf-buildid-list.txt

Diff comments View file @ e4b546a

1	perf-buildid-list(1)	1	perf-buildid-list(1)
2	====================	2	====================
3		3
4	NAME	4	NAME
5	----	5	----
6	perf-buildid-list - List the buildids in a perf.data file	6	perf-buildid-list - List the buildids in a perf.data file
7		7
8	SYNOPSIS	8	SYNOPSIS
9	--------	9	--------
10	[verse]	10	[verse]
11	'perf buildid-list <options>'	11	'perf buildid-list <options>'
12		12
13	DESCRIPTION	13	DESCRIPTION
14	-----------	14	-----------
15	This command displays the buildids found in a perf.data file, so that other	15	This command displays the buildids found in a perf.data file, so that other
16	tools can be used to fetch packages with matching symbol tables for use by	16	tools can be used to fetch packages with matching symbol tables for use by
17	perf report.	17	perf report.
18		18
19	OPTIONS	19	OPTIONS
20	-------	20	-------
		21	-H::
		22	--with-hits::
		23	Show only DSOs with hits.
21	-i::	24	-i::
22	--input=::	25	--input=::
23	Input file name. (default: perf.data)	26	Input file name. (default: perf.data)
24	-f::	27	-f::
25	--force::	28	--force::
26	Don't do ownership validation.	29	Don't do ownership validation.
27	-v::	30	-v::
28	--verbose::	31	--verbose::
29	Be more verbose.	32	Be more verbose.
30		33
31	SEE ALSO	34	SEE ALSO
32	--------	35	--------
33	linkperf:perf-record[1], linkperf:perf-top[1],	36	linkperf:perf-record[1], linkperf:perf-top[1],
34	linkperf:perf-report[1]	37	linkperf:perf-report[1]
35		38

tools/perf/Documentation/perf-diff.txt

Diff comments View file @ e4b546a

 perf-diff(1)
 ============
 NAME
 ----
 perf-diff - Read two perf.data files and display the differential profile
 SYNOPSIS
 --------
 [verse]
 'perf diff' [oldfile] [newfile]
 DESCRIPTION
 -----------
 This command displays the performance difference amongst two perf.data files
 captured via perf record.
 If no parameters are passed it will assume perf.data.old and perf.data.
 OPTIONS
 -------
+-M::
+--displacement::
+        Show position displacement relative to baseline.
+-D::
+--dump-raw-trace::
+        Dump raw trace in ASCII.
+-m::
+--modules::
+        Load module symbols. WARNING: use only with -k and LIVE kernel
 -d::
 --dsos=::
 	Only consider symbols in these dsos. CSV that understands
 	file://filename entries.
 -C::
 --comms=::
 	Only consider symbols in these comms. CSV that understands
 	file://filename entries.
 -S::
 --symbols=::
 	Only consider these symbols. CSV that understands
 	file://filename entries.
 -s::
 --sort=::
 	Sort by key(s): pid, comm, dso, symbol.
 -t::
 --field-separator=::
 	Use a special separator character and don't pad with spaces, replacing
-	all occurances of this separator in symbol names (and other output)
+	all occurrences of this separator in symbol names (and other output)
 	with a '.' character, that thus it's the only non valid separator.
 -v::
 --verbose::
 	Be verbose, for instance, show the raw counts in addition to the
 	diff.
+-f::
+--force::
+       Don't complain, do it.
 SEE ALSO
 --------
 linkperf:perf-record[1]

tools/perf/Documentation/perf-kvm.txt

Diff comments View file @ e4b546a

 perf-kvm(1)
 ===========
 NAME
 ----
 perf-kvm - Tool to trace/measure kvm guest os
 SYNOPSIS
 --------
 [verse]
 'perf kvm' [--host] [--guest] [--guestmount=<path>
 	[--guestkallsyms=<path> --guestmodules=<path> | --guestvmlinux=<path>]]
 	{top|record|report|diff|buildid-list}
 'perf kvm' [--host] [--guest] [--guestkallsyms=<path> --guestmodules=<path>
 	| --guestvmlinux=<path>] {top|record|report|diff|buildid-list}
 DESCRIPTION
 -----------
 There are a couple of variants of perf kvm:
   'perf kvm [options] top <command>' to generates and displays
   a performance counter profile of guest os in realtime
   of an arbitrary workload.
-  'perf kvm record <command>' to record the performance couinter profile
+  'perf kvm record <command>' to record the performance counter profile
   of an arbitrary workload and save it into a perf data file. If both
   --host and --guest are input, the perf data file name is perf.data.kvm.
   If there is  no --host but --guest, the file name is perf.data.guest.
   If there is no --guest but --host, the file name is perf.data.host.
   'perf kvm report' to display the performance counter profile information
   recorded via perf kvm record.
   'perf kvm diff' to displays the performance difference amongst two perf.data
   files captured via perf record.
   'perf kvm buildid-list' to  display the buildids found in a perf data file,
   so that other tools can be used to fetch packages with matching symbol tables
   for use by perf report.
 OPTIONS
 -------
+-i::
+--input=::
+        Input file name.
+-o::
+--output::
+        Output file name.
 --host=::
         Collect host side performance profile.
 --guest=::
         Collect guest side performance profile.
 --guestmount=<path>::
 	Guest os root file system mount directory. Users mounts guest os
         root directories under <path> by a specific filesystem access method,
 	typically, sshfs. For example, start 2 guest os. The one's pid is 8888
 	and the other's is 9999.
         #mkdir ~/guestmount; cd ~/guestmount
         #sshfs -o allow_other,direct_io -p 5551 localhost:/ 8888/
         #sshfs -o allow_other,direct_io -p 5552 localhost:/ 9999/
         #perf kvm --host --guest --guestmount=~/guestmount top
 --guestkallsyms=<path>::
         Guest os /proc/kallsyms file copy. 'perf' kvm' reads it to get guest
 	kernel symbols. Users copy it out from guest os.
 --guestmodules=<path>::
 	Guest os /proc/modules file copy. 'perf' kvm' reads it to get guest
 	kernel module information. Users copy it out from guest os.
 --guestvmlinux=<path>::
 	Guest os kernel vmlinux.
 SEE ALSO
 --------
 linkperf:perf-top[1], linkperf:perf-record[1], linkperf:perf-report[1],
 linkperf:perf-diff[1], linkperf:perf-buildid-list[1]

tools/perf/Documentation/perf-lock.txt

Diff comments View file @ e4b546a

 perf-lock(1)
 ============
 NAME
 ----
 perf-lock - Analyze lock events
 SYNOPSIS
 --------
 [verse]
 'perf lock' {record|report|trace}
 DESCRIPTION
 -----------
 You can analyze various lock behaviours
 and statistics with this 'perf lock' command.
   'perf lock record <command>' records lock events
   between start and end <command>. And this command
   produces the file "perf.data" which contains tracing
   results of lock events.
   'perf lock trace' shows raw lock events.
   'perf lock report' reports statistical data.
+OPTIONS
+-------
+-i::
+--input=<file>::
+        Input file name.
+-v::
+--verbose::
+        Be more verbose (show symbol address, etc).
+-D::
+--dump-raw-trace::
+        Dump raw trace in ASCII.
 SEE ALSO
 --------
 linkperf:perf[1]

tools/perf/Documentation/perf-probe.txt

Diff comments View file @ e4b546a

1	perf-probe(1)	1	perf-probe(1)
2	=============	2	=============
3		3
4	NAME	4	NAME
5	----	5	----
6	perf-probe - Define new dynamic tracepoints	6	perf-probe - Define new dynamic tracepoints
7		7
8	SYNOPSIS	8	SYNOPSIS
9	--------	9	--------
10	[verse]	10	[verse]
11	'perf probe' [options] --add='PROBE' [...]	11	'perf probe' [options] --add='PROBE' [...]
12	or	12	or
13	'perf probe' [options] PROBE	13	'perf probe' [options] PROBE
14	or	14	or
15	'perf probe' [options] --del='[GROUP:]EVENT' [...]	15	'perf probe' [options] --del='[GROUP:]EVENT' [...]
16	or	16	or
17	'perf probe' --list	17	'perf probe' --list
18	or	18	or
19	'perf probe' [options] --line='FUNC[:RLN[+NUM\|:RLN2]]\|SRC:ALN[+NUM\|:ALN2]'	19	'perf probe' [options] --line='FUNC[:RLN[+NUM\|:RLN2]]\|SRC:ALN[+NUM\|:ALN2]'
20	or	20	or
21	'perf probe' [options] --vars='PROBEPOINT'	21	'perf probe' [options] --vars='PROBEPOINT'
22		22
23	DESCRIPTION	23	DESCRIPTION
24	-----------	24	-----------
25	This command defines dynamic tracepoint events, by symbol and registers	25	This command defines dynamic tracepoint events, by symbol and registers
26	without debuginfo, or by C expressions (C line numbers, C function names,	26	without debuginfo, or by C expressions (C line numbers, C function names,
27	and C local variables) with debuginfo.	27	and C local variables) with debuginfo.
28		28
29		29
30	OPTIONS	30	OPTIONS
31	-------	31	-------
32	-k::	32	-k::
33	--vmlinux=PATH::	33	--vmlinux=PATH::
34	Specify vmlinux path which has debuginfo (Dwarf binary).	34	Specify vmlinux path which has debuginfo (Dwarf binary).
35		35
36	-m::	36	-m::
37	--module=MODNAME::	37	--module=MODNAME::
38	Specify module name in which perf-probe searches probe points	38	Specify module name in which perf-probe searches probe points
39	or lines.	39	or lines.
40		40
41	-s::	41	-s::
42	--source=PATH::	42	--source=PATH::
43	Specify path to kernel source.	43	Specify path to kernel source.
44		44
45	-v::	45	-v::
46	--verbose::	46	--verbose::
47	Be more verbose (show parsed arguments, etc).	47	Be more verbose (show parsed arguments, etc).
48		48
49	-a::	49	-a::
50	--add=::	50	--add=::
51	Define a probe event (see PROBE SYNTAX for detail).	51	Define a probe event (see PROBE SYNTAX for detail).
52		52
53	-d::	53	-d::
54	--del=::	54	--del=::
55	Delete probe events. This accepts glob wildcards('*', '?') and character	55	Delete probe events. This accepts glob wildcards('*', '?') and character
56	classes(e.g. [a-z], [!A-Z]).	56	classes(e.g. [a-z], [!A-Z]).
57		57
58	-l::	58	-l::
59	--list::	59	--list::
60	List up current probe events.	60	List up current probe events.
61		61
62	-L::	62	-L::
63	--line=::	63	--line=::
64	Show source code lines which can be probed. This needs an argument	64	Show source code lines which can be probed. This needs an argument
65	which specifies a range of the source code. (see LINE SYNTAX for detail)	65	which specifies a range of the source code. (see LINE SYNTAX for detail)
66		66
67	-V::	67	-V::
68	--vars=::	68	--vars=::
69	Show available local variables at given probe point. The argument	69	Show available local variables at given probe point. The argument
70	syntax is same as PROBE SYNTAX, but NO ARGs.	70	syntax is same as PROBE SYNTAX, but NO ARGs.
71		71
72	--externs::	72	--externs::
73	(Only for --vars) Show external defined variables in addition to local	73	(Only for --vars) Show external defined variables in addition to local
74	variables.	74	variables.
75		75
76	-f::	76	-f::
77	--force::	77	--force::
78	Forcibly add events with existing name.	78	Forcibly add events with existing name.
79		79
80	-n::	80	-n::
81	--dry-run::	81	--dry-run::
82	Dry run. With this option, --add and --del doesn't execute actual	82	Dry run. With this option, --add and --del doesn't execute actual
83	adding and removal operations.	83	adding and removal operations.
84		84
85	--max-probes::	85	--max-probes::
86	Set the maximum number of probe points for an event. Default is 128.	86	Set the maximum number of probe points for an event. Default is 128.
87		87
88	PROBE SYNTAX	88	PROBE SYNTAX
89	------------	89	------------
90	Probe points are defined by following syntax.	90	Probe points are defined by following syntax.
91		91
92	1) Define event based on function name	92	1) Define event based on function name
93	[EVENT=]FUNC[@SRC][:RLN\|+OFFS\|%return\|;PTN] [ARG ...]	93	[EVENT=]FUNC[@SRC][:RLN\|+OFFS\|%return\|;PTN] [ARG ...]
94		94
95	2) Define event based on source file with line number	95	2) Define event based on source file with line number
96	[EVENT=]SRC:ALN [ARG ...]	96	[EVENT=]SRC:ALN [ARG ...]
97		97
98	3) Define event based on source file with lazy pattern	98	3) Define event based on source file with lazy pattern
99	[EVENT=]SRC;PTN [ARG ...]	99	[EVENT=]SRC;PTN [ARG ...]
100		100
101		101
102	'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'.	102	'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'.
103	'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition. In addition, '@SRC' specifies a source file which has that function.	103	'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition. In addition, '@SRC' specifies a source file which has that function.
104	It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.	104	It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.
105	'ARG' specifies the arguments of this probe point, (see PROBE ARGUMENT).	105	'ARG' specifies the arguments of this probe point, (see PROBE ARGUMENT).
106		106
107	PROBE ARGUMENT	107	PROBE ARGUMENT
108	--------------	108	--------------
109	Each probe argument follows below syntax.	109	Each probe argument follows below syntax.
110		110
111	[NAME=]LOCALVAR\|$retval\|%REG\|@SYMBOL[:TYPE]	111	[NAME=]LOCALVAR\|$retval\|%REG\|@SYMBOL[:TYPE]
112		112
113	'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)	113	'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)
114	'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.	114	'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
115		115
116	LINE SYNTAX	116	LINE SYNTAX
117	-----------	117	-----------
118	Line range is descripted by following syntax.	118	Line range is described by following syntax.
119		119
120	"FUNC[:RLN[+NUM\|-RLN2]]\|SRC:ALN[+NUM\|-ALN2]"	120	"FUNC[:RLN[+NUM\|-RLN2]]\|SRC:ALN[+NUM\|-ALN2]"
121		121
122	FUNC specifies the function name of showing lines. 'RLN' is the start line	122	FUNC specifies the function name of showing lines. 'RLN' is the start line
123	number from function entry line, and 'RLN2' is the end line number. As same as	123	number from function entry line, and 'RLN2' is the end line number. As same as
124	probe syntax, 'SRC' means the source file path, 'ALN' is start line number,	124	probe syntax, 'SRC' means the source file path, 'ALN' is start line number,
125	and 'ALN2' is end line number in the file. It is also possible to specify how	125	and 'ALN2' is end line number in the file. It is also possible to specify how
126	many lines to show by using 'NUM'.	126	many lines to show by using 'NUM'.
127	So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function.	127	So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function.
128		128
129	LAZY MATCHING	129	LAZY MATCHING
130	-------------	130	-------------
131	The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]).	131	The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]).
132		132
133	e.g.	133	e.g.
134	'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.	134	'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.
135		135
136	This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.)	136	This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.)
137		137
138		138
139	EXAMPLES	139	EXAMPLES
140	--------	140	--------
141	Display which lines in schedule() can be probed:	141	Display which lines in schedule() can be probed:
142		142
143	./perf probe --line schedule	143	./perf probe --line schedule
144		144
145	Add a probe on schedule() function 12th line with recording cpu local variable:	145	Add a probe on schedule() function 12th line with recording cpu local variable:
146		146
147	./perf probe schedule:12 cpu	147	./perf probe schedule:12 cpu
148	or	148	or
149	./perf probe --add='schedule:12 cpu'	149	./perf probe --add='schedule:12 cpu'
150		150
151	this will add one or more probes which has the name start with "schedule".	151	this will add one or more probes which has the name start with "schedule".
152		152
153	Add probes on lines in schedule() function which calls update_rq_clock().	153	Add probes on lines in schedule() function which calls update_rq_clock().
154		154
155	./perf probe 'schedule;update_rq_clock*'	155	./perf probe 'schedule;update_rq_clock*'
156	or	156	or
157	./perf probe --add='schedule;update_rq_clock*'	157	./perf probe --add='schedule;update_rq_clock*'
158		158
159	Delete all probes on schedule().	159	Delete all probes on schedule().
160		160
161	./perf probe --del='schedule*'	161	./perf probe --del='schedule*'
162		162
163		163
164	SEE ALSO	164	SEE ALSO
165	--------	165	--------
166	linkperf:perf-trace[1], linkperf:perf-record[1]	166	linkperf:perf-trace[1], linkperf:perf-record[1]
167		167

tools/perf/Documentation/perf-record.txt

Diff comments View file @ e4b546a

 perf-record(1)
 ==============
 NAME
 ----
 perf-record - Run a command and record its profile into perf.data
 SYNOPSIS
 --------
 [verse]
 'perf record' [-e <EVENT> | --event=EVENT] [-l] [-a] <command>
 'perf record' [-e <EVENT> | --event=EVENT] [-l] [-a] -- <command> [<options>]
 DESCRIPTION
 -----------
 This command runs a command and gathers a performance counter profile
 from it, into perf.data - without displaying anything.
 This file can then be inspected later on, using 'perf report'.
 OPTIONS
 -------
 <command>...::
 	Any command you can specify in a shell.
 -e::
 --event=::
 	Select the PMU event. Selection can be:
         - a symbolic event name	(use 'perf list' to list all events)
         - a raw PMU event (eventsel+umask) in the form of rNNN where NNN is a
 	  hexadecimal event descriptor.
         - a hardware breakpoint event in the form of '\mem:addr[:access]'
           where addr is the address in memory you want to break in.
           Access is the memory access type (read, write, execute) it can
           be passed as follows: '\mem:addr[:[r][w][x]]'.
           If you want to profile read-write accesses in 0x1000, just set
           'mem:0x1000:rw'.
+--filter=<filter>::
+        Event filter.
 -a::
-        System-wide collection.
+--all-cpus::
+        System-wide collection from all CPUs.
 -l::
         Scale counter values.
 -p::
 --pid=::
-	Record events on existing pid.
+	Record events on existing process ID.
+-t::
+--tid=::
+        Record events on existing thread ID.
 -r::
 --realtime=::
 	Collect data with this RT SCHED_FIFO priority.
 -A::
 --append::
 	Append to the output file to do incremental profiling.
 -f::
 --force::
 	Overwrite existing data file. (deprecated)
 -c::
 --count=::
 	Event period to sample.
 -o::
 --output=::
 	Output file name.
 -i::
 --no-inherit::
 	Child tasks do not inherit counters.
 -F::
 --freq=::
 	Profile at this frequency.
 -m::
 --mmap-pages=::
 	Number of mmap data pages.
 -g::
 --call-graph::
 	Do call-graph (stack chain/backtrace) recording.
 -q::
 --quiet::
 	Don't print any message, useful for scripting.
 -v::
 --verbose::
 	Be more verbose (show counter open errors, etc).
 -s::
 --stat::
 	Per thread counts.
 -d::
 --data::
 	Sample addresses.
 -n::
 --no-samples::
 	Don't sample.
 -R::
 --raw-samples::
 Collect raw sample records from all opened counters (default for tracepoint counters).
 -C::
 --cpu::
-Collect samples only on the list of cpus provided. Multiple CPUs can be provided as a
+Collect samples only on the list of CPUs provided. Multiple CPUs can be provided as a
-comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+comma-separated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
 In per-thread mode with inheritance mode on (default), samples are captured only when
 the thread executes on the designated CPUs. Default is to monitor all CPUs.
 -N::
 --no-buildid-cache::
 Do not update the builid cache. This saves some overhead in situations
 where the information in the perf.data file (which includes buildids)
 is sufficient.
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]

tools/perf/Documentation/perf-report.txt

Diff comments View file @ e4b546a

 perf-report(1)
 ==============
 NAME
 ----
 perf-report - Read perf.data (created by perf record) and display the profile
 SYNOPSIS
 --------
 [verse]
 'perf report' [-i <file> | --input=file]
 DESCRIPTION
 -----------
 This command displays the performance counter profile information recorded
 via perf record.
 OPTIONS
 -------
 -i::
 --input=::
         Input file name. (default: perf.data)
+-v::
+--verbose::
+        Be more verbose. (show symbol address, etc)
 -d::
 --dsos=::
 	Only consider symbols in these dsos. CSV that understands
 	file://filename entries.
 -n::
 --show-nr-samples::
 	Show the number of samples for each symbol
+--showcpuutilization::
+        Show sample percentage for different cpu modes.
 -T::
 --threads::
 	Show per-thread event counters
 -C::
 --comms=::
 	Only consider symbols in these comms. CSV that understands
 	file://filename entries.
 -S::
 --symbols=::
 	Only consider these symbols. CSV that understands
 	file://filename entries.
+-U::
+--hide-unresolved::
+        Only display entries resolved to a symbol.
 -s::
 --sort=::
 	Sort by key(s): pid, comm, dso, symbol, parent.
+-p::
+--parent=<regex>::
+        regex filter to identify parent, see: '--sort parent'
+-x::
+--exclude-other::
+        Only display entries with parent-match.
 -w::
---field-width=::
+--column-widths=<width[,width...]>::
 	Force each column width to the provided list, for large terminal
 	readability.
 -t::
 --field-separator=::
 	Use a special separator character and don't pad with spaces, replacing
-	all occurances of this separator in symbol names (and other output)
+	all occurrences of this separator in symbol names (and other output)
 	with a '.' character, that thus it's the only non valid separator.
+-D::
+--dump-raw-trace::
+        Dump raw trace in ASCII.
 -g [type,min]::
 --call-graph::
-        Display callchains using type and min percent threshold.
+        Display call chains using type and min percent threshold.
 	type can be either:
-	- flat: single column, linear exposure of callchains.
+	- flat: single column, linear exposure of call chains.
 	- graph: use a graph tree, displaying absolute overhead rates.
 	- fractal: like graph, but displays relative rates. Each branch of
 		 the tree is considered as a new profiled object. +
 	Default: fractal,0.5.
+--pretty=<key>::
+        Pretty printing style.  key: normal, raw
 --stdio:: Use the stdio interface.
 --tui:: Use the TUI interface, that is integrated with annotate and allows
         zooming into DSOs or threads, among other features. Use of --tui
 	requires a tty, if one is not present, as when piping to other
 	commands, the stdio interface is used.
+-k::
+--vmlinux=<file>::
+        vmlinux pathname
+-m::
+--modules::
+        Load module symbols. WARNING: This should only be used with -k and
+        a LIVE kernel.
+-f::
+--force::
+        Don't complain, do it.
 SEE ALSO
 --------
 linkperf:perf-stat[1]

tools/perf/Documentation/perf-sched.txt

Diff comments View file @ e4b546a

 perf-sched(1)
 ==============
 NAME
 ----
 perf-sched - Tool to trace/measure scheduler properties (latencies)
 SYNOPSIS
 --------
 [verse]
-'perf sched' {record|latency|replay|trace}
+'perf sched' {record|latency|map|replay|trace}
 DESCRIPTION
 -----------
-There are four variants of perf sched:
+There are five variants of perf sched:
   'perf sched record <command>' to record the scheduling events
   of an arbitrary workload.
   'perf sched latency' to report the per task scheduling latencies
   and other scheduling properties of the workload.
   'perf sched trace' to see a detailed trace of the workload that
   was recorded.
   'perf sched replay' to simulate the workload that was recorded
   via perf sched record. (this is done by starting up mockup threads
   that mimic the workload based on the events in the trace. These
   threads can then replay the timings (CPU runtime and sleep patterns)
   of the workload as it occurred when it was recorded - and can repeat
   it a number of times, measuring its performance.)
+  'perf sched map' to print a textual context-switching outline of
+  workload captured via perf sched record.  Columns stand for
+  individual CPUs, and the two-letter shortcuts stand for tasks that
+  are running on a CPU. A '*' denotes the CPU that had the event, and
+  a dot signals an idle CPU.
 OPTIONS
 -------
+-i::
+--input=<file>::
+        Input file name. (default: perf.data)
+-v::
+--verbose::
+        Be more verbose. (show symbol address, etc)
 -D::
 --dump-raw-trace=::
         Display verbose dump of the sched data.
 SEE ALSO
 --------
 linkperf:perf-record[1]

tools/perf/Documentation/perf-script.txt

Diff comments View file @ e4b546a

 perf-script(1)
 =============
 NAME
 ----
 perf-script - Read perf.data (created by perf record) and display trace output
 SYNOPSIS
 --------
 [verse]
 'perf script' [<options>]
 'perf script' [<options>] record <script> [<record-options>] <command>
 'perf script' [<options>] report <script> [script-args]
 'perf script' [<options>] <script> <required-script-args> [<record-options>] <command>
 'perf script' [<options>] <top-script> [script-args]
 DESCRIPTION
 -----------
 This command reads the input file and displays the trace recorded.
 There are several variants of perf script:
   'perf script' to see a detailed trace of the workload that was
   recorded.
   You can also run a set of pre-canned scripts that aggregate and
   summarize the raw trace data in various ways (the list of scripts is
   available via 'perf script -l').  The following variants allow you to
   record and run those scripts:
   'perf script record <script> <command>' to record the events required
   for 'perf script report'.  <script> is the name displayed in the
   output of 'perf script --list' i.e. the actual script name minus any
   language extension.  If <command> is not specified, the events are
   recorded using the -a (system-wide) 'perf record' option.
   'perf script report <script> [args]' to run and display the results
   of <script>.  <script> is the name displayed in the output of 'perf
   trace --list' i.e. the actual script name minus any language
   extension.  The perf.data output from a previous run of 'perf script
   record <script>' is used and should be present for this command to
   succeed.  [args] refers to the (mainly optional) args expected by
   the script.
   'perf script <script> <required-script-args> <command>' to both
   record the events required for <script> and to run the <script>
   using 'live-mode' i.e. without writing anything to disk.  <script>
   is the name displayed in the output of 'perf script --list' i.e. the
   actual script name minus any language extension.  If <command> is
   not specified, the events are recorded using the -a (system-wide)
   'perf record' option.  If <script> has any required args, they
   should be specified before <command>.  This mode doesn't allow for
   optional script args to be specified; if optional script args are
   desired, they can be specified using separate 'perf script record'
   and 'perf script report' commands, with the stdout of the record step
   piped to the stdin of the report script, using the '-o -' and '-i -'
   options of the corresponding commands.
   'perf script <top-script>' to both record the events required for
   <top-script> and to run the <top-script> using 'live-mode'
   i.e. without writing anything to disk.  <top-script> is the name
   displayed in the output of 'perf script --list' i.e. the actual
   script name minus any language extension; a <top-script> is defined
   as any script name ending with the string 'top'.
   [<record-options>] can be passed to the record steps of 'perf script
   record' and 'live-mode' variants; this isn't possible however for
   <top-script> 'live-mode' or 'perf script report' variants.
   See the 'SEE ALSO' section for links to language-specific
   information on how to write and run your own trace scripts.
 OPTIONS
 -------
 <command>...::
 	Any command you can specify in a shell.
 -D::
 --dump-raw-script=::
         Display verbose dump of the trace data.
 -L::
 --Latency=::
         Show latency attributes (irqs/preemption disabled, etc).
 -l::
 --list=::
         Display a list of available trace scripts.
 -s ['lang']::
 --script=::
         Process trace data with the given script ([lang]:script[.ext]).
 	If the string 'lang' is specified in place of a script name, a
         list of supported languages will be displayed instead.
 -g::
 --gen-script=::
         Generate perf-script.[ext] starter script for given language,
         using current perf.data.
 -a::
         Force system-wide collection.  Scripts run without a <command>
         normally use -a by default, while scripts run with a <command>
         normally don't - this option allows the latter to be run in
         system-wide mode.
+-i::
+--input=::
+        Input file name.
+-d::
+--debug-mode::
+        Do various checks like samples ordering and lost events.
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
 linkperf:perf-script-python[1]

tools/perf/Documentation/perf-stat.txt

Diff comments View file @ e4b546a

 perf-stat(1)
 ============
 NAME
 ----
 perf-stat - Run a command and gather performance counter statistics
 SYNOPSIS
 --------
 [verse]
-'perf stat' [-e <EVENT> | --event=EVENT] [-S] [-a] <command>
+'perf stat' [-e <EVENT> | --event=EVENT] [-a] <command>
-'perf stat' [-e <EVENT> | --event=EVENT] [-S] [-a] -- <command> [<options>]
+'perf stat' [-e <EVENT> | --event=EVENT] [-a] -- <command> [<options>]
 DESCRIPTION
 -----------
 This command runs a command and gathers performance counter statistics
 from it.
 OPTIONS
 -------
 <command>...::
 	Any command you can specify in a shell.
 -e::
 --event=::
 	Select the PMU event. Selection can be a symbolic event name
 	(use 'perf list' to list all events) or a raw PMU
 	event (eventsel+umask) in the form of rNNN where NNN is a
 	 hexadecimal event descriptor.
 -i::
 --no-inherit::
         child tasks do not inherit counters
 -p::
 --pid=<pid>::
-        stat events on existing pid
+        stat events on existing process id
+-t::
+--tid=<tid>::
+        stat events on existing thread id
 -a::
-        system-wide collection
+--all-cpus::
+        system-wide collection from all CPUs
 -c::
-        scale counter values
+--scale::
+	scale/normalize counter values
+-r::
+--repeat=<n>::
+	repeat command and print average + stddev (max: 100)
 -B::
+--big-num::
         print large numbers with thousands' separators according to locale
 -C::
 --cpu=::
-Count only on the list of cpus provided. Multiple CPUs can be provided as a
+Count only on the list of CPUs provided. Multiple CPUs can be provided as a
-comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+comma-separated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
 In per-thread mode, this option is ignored. The -a option is still necessary
 to activate system-wide monitoring. Default is to count on all CPUs.
 -A::
 --no-aggr::
 Do not aggregate counts across all monitored CPUs in system-wide mode (-a).
 This option is only valid in system-wide mode.
+-n::
+--null::
+        null run - don't start any counters
+-v::
+--verbose::
+        be more verbose (show counter open errors, etc)
+-x SEP::
+--field-separator SEP::
+print counts using a CSV-style output to make it easy to import directly into
+spreadsheets. Columns are separated by the string specified in SEP.
 EXAMPLES
 --------
 $ perf stat -- make -j
  Performance counter stats for 'make -j':
     8117.370256  task clock ticks     #      11.281 CPU utilization factor
             678  context switches     #       0.000 M/sec
             133  CPU migrations       #       0.000 M/sec
          235724  pagefaults           #       0.029 M/sec
     24821162526  CPU cycles           #    3057.784 M/sec
     18687303457  instructions         #    2302.138 M/sec
       172158895  cache references     #      21.209 M/sec
        27075259  cache misses         #       3.335 M/sec
  Wall-clock time elapsed:   719.554352 msecs
 SEE ALSO
 --------
 linkperf:perf-top[1], linkperf:perf-list[1]

tools/perf/Documentation/perf-test.txt

Diff comments View file @ e4b546a

1	perf-test(1)	1	perf-test(1)
2	============	2	============
3		3
4	NAME	4	NAME
5	----	5	----
6	perf-test - Runs sanity tests.	6	perf-test - Runs sanity tests.
7		7
8	SYNOPSIS	8	SYNOPSIS
9	--------	9	--------
10	[verse]	10	[verse]
11	'perf test <options>'	11	'perf test <options>'
12		12
13	DESCRIPTION	13	DESCRIPTION
14	-----------	14	-----------
15	This command does assorted sanity tests, initially thru linked routines but	15	This command does assorted sanity tests, initially through linked routines but
16	also will look for a directory with more tests in the form of scripts.	16	also will look for a directory with more tests in the form of scripts.
17		17
18	OPTIONS	18	OPTIONS
19	-------	19	-------
20	-v::	20	-v::
21	--verbose::	21	--verbose::
22	Be more verbose.	22	Be more verbose.
23		23

tools/perf/Documentation/perf-top.txt

Diff comments View file @ e4b546a

 perf-top(1)
 ===========
 NAME
 ----
 perf-top - System profiling tool.
 SYNOPSIS
 --------
 [verse]
 'perf top' [-e <EVENT> | --event=EVENT] [<options>]
 DESCRIPTION
 -----------
-This command generates and displays a performance counter profile in realtime.
+This command generates and displays a performance counter profile in real time.
 OPTIONS
 -------
 -a::
 --all-cpus::
         System-wide collection.  (default)
 -c <count>::
 --count=<count>::
 	Event period to sample.
 -C <cpu-list>::
 --cpu=<cpu>::
-Monitor only on the list of cpus provided. Multiple CPUs can be provided as a
+Monitor only on the list of CPUs provided. Multiple CPUs can be provided as a
-comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+comma-separated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
 Default is to monitor all CPUS.
 -d <seconds>::
 --delay=<seconds>::
 	Number of seconds to delay between refreshes.
 -e <event>::
 --event=<event>::
 	Select the PMU event. Selection can be a symbolic event name
 	(use 'perf list' to list all events) or a raw PMU
 	event (eventsel+umask) in the form of rNNN where NNN is a
 	hexadecimal event descriptor.
 -E <entries>::
 --entries=<entries>::
 	Display this many functions.
 -f <count>::
 --count-filter=<count>::
 	Only display functions with more events than this.
+-g::
+--group::
+        Put the counters into a counter group.
 -F <freq>::
 --freq=<freq>::
 	Profile at this frequency.
 -i::
 --inherit::
 	Child tasks inherit counters, only makes sens with -p option.
 -k <path>::
 --vmlinux=<path>::
 	Path to vmlinux.  Required for annotation functionality.
 -m <pages>::
 --mmap-pages=<pages>::
 	Number of mmapped data pages.
 -p <pid>::
 --pid=<pid>::
-	Profile events on existing pid.
+	Profile events on existing Process ID.
+-t <tid>::
+--tid=<tid>::
+        Profile events on existing thread ID.
 -r <priority>::
 --realtime=<priority>::
 	Collect data with this RT SCHED_FIFO priority.
 -s <symbol>::
 --sym-annotate=<symbol>::
         Annotate this symbol.
+-K::
+--hide_kernel_symbols::
+        Hide kernel symbols.
+-U::
+--hide_user_symbols::
+        Hide user symbols.
+-D::
+--dump-symtab::
+        Dump the symbol table used for profiling.
 -v::
 --verbose::
 	Be more verbose (show counter open errors, etc).
 -z::
 --zero::
 	Zero history across display updates.
 INTERACTIVE PROMPTING KEYS
 --------------------------
 [d]::
 	Display refresh delay.
 [e]::
 	Number of entries to display.
 [E]::
 	Event to display when multiple counters are active.
 [f]::
 	Profile display filter (>= hit count).
 [F]::
 	Annotation display filter (>= % of total).
 [s]::
 	Annotate symbol.
 [S]::
 	Stop annotation, return to full profile display.
 [w]::
 	Toggle between weighted sum and individual count[E]r profile.
 [z]::
 	Toggle event count zeroing across display updates.
 [qQ]::
 	Quit.
 Pressing any unmapped key displays a menu, and prompts for input.
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]

tools/perf/builtin-diff.c

Diff comments View file @ e4b546a

1	/*	1	/*
2	* builtin-diff.c	2	* builtin-diff.c
3	*	3	*
4	* Builtin diff command: Analyze two perf.data input files, look up and read	4	* Builtin diff command: Analyze two perf.data input files, look up and read
5	* DSOs and symbol information, sort them and produce a diff.	5	* DSOs and symbol information, sort them and produce a diff.
6	*/	6	*/
7	#include "builtin.h"	7	#include "builtin.h"
8		8
9	#include "util/debug.h"	9	#include "util/debug.h"
10	#include "util/event.h"	10	#include "util/event.h"
11	#include "util/hist.h"	11	#include "util/hist.h"
12	#include "util/session.h"	12	#include "util/session.h"
13	#include "util/sort.h"	13	#include "util/sort.h"
14	#include "util/symbol.h"	14	#include "util/symbol.h"
15	#include "util/util.h"	15	#include "util/util.h"
16		16
17	#include <stdlib.h>	17	#include <stdlib.h>
18		18
19	static char const *input_old = "perf.data.old",	19	static char const *input_old = "perf.data.old",
20	*input_new = "perf.data";	20	*input_new = "perf.data";
21	static char diff__default_sort_order[] = "dso,symbol";	21	static char diff__default_sort_order[] = "dso,symbol";
22	static bool force;	22	static bool force;
23	static bool show_displacement;	23	static bool show_displacement;
24		24
25	static int hists__add_entry(struct hists *self,	25	static int hists__add_entry(struct hists *self,
26	struct addr_location *al, u64 period)	26	struct addr_location *al, u64 period)
27	{	27	{
28	if (__hists__add_entry(self, al, NULL, period) != NULL)	28	if (__hists__add_entry(self, al, NULL, period) != NULL)
29	return 0;	29	return 0;
30	return -ENOMEM;	30	return -ENOMEM;
31	}	31	}
32		32
33	static int diff__process_sample_event(event_t event, struct perf_session session)	33	static int diff__process_sample_event(event_t event, struct perf_session session)
34	{	34	{
35	struct addr_location al;	35	struct addr_location al;
36	struct sample_data data = { .period = 1, };	36	struct sample_data data = { .period = 1, };
37		37
38	if (event__preprocess_sample(event, session, &al, &data, NULL) < 0) {	38	if (event__preprocess_sample(event, session, &al, &data, NULL) < 0) {
39	pr_warning("problem processing %d event, skipping it.\n",	39	pr_warning("problem processing %d event, skipping it.\n",
40	event->header.type);	40	event->header.type);
41	return -1;	41	return -1;
42	}	42	}
43		43
44	if (al.filtered \|\| al.sym == NULL)	44	if (al.filtered \|\| al.sym == NULL)
45	return 0;	45	return 0;
46		46
47	if (hists__add_entry(&session->hists, &al, data.period)) {	47	if (hists__add_entry(&session->hists, &al, data.period)) {
48	pr_warning("problem incrementing symbol period, skipping event\n");	48	pr_warning("problem incrementing symbol period, skipping event\n");
49	return -1;	49	return -1;
50	}	50	}
51		51
52	session->hists.stats.total_period += data.period;	52	session->hists.stats.total_period += data.period;
53	return 0;	53	return 0;
54	}	54	}
55		55
56	static struct perf_event_ops event_ops = {	56	static struct perf_event_ops event_ops = {
57	.sample = diff__process_sample_event,	57	.sample = diff__process_sample_event,
58	.mmap = event__process_mmap,	58	.mmap = event__process_mmap,
59	.comm = event__process_comm,	59	.comm = event__process_comm,
60	.exit = event__process_task,	60	.exit = event__process_task,
61	.fork = event__process_task,	61	.fork = event__process_task,
62	.lost = event__process_lost,	62	.lost = event__process_lost,
63	};	63	};
64		64
65	static void perf_session__insert_hist_entry_by_name(struct rb_root *root,	65	static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
66	struct hist_entry *he)	66	struct hist_entry *he)
67	{	67	{
68	struct rb_node **p = &root->rb_node;	68	struct rb_node **p = &root->rb_node;
69	struct rb_node *parent = NULL;	69	struct rb_node *parent = NULL;
70	struct hist_entry *iter;	70	struct hist_entry *iter;
71		71
72	while (*p != NULL) {	72	while (*p != NULL) {
73	parent = *p;	73	parent = *p;
74	iter = rb_entry(parent, struct hist_entry, rb_node);	74	iter = rb_entry(parent, struct hist_entry, rb_node);
75	if (hist_entry__cmp(he, iter) < 0)	75	if (hist_entry__cmp(he, iter) < 0)
76	p = &(*p)->rb_left;	76	p = &(*p)->rb_left;
77	else	77	else
78	p = &(*p)->rb_right;	78	p = &(*p)->rb_right;
79	}	79	}
80		80
81	rb_link_node(&he->rb_node, parent, p);	81	rb_link_node(&he->rb_node, parent, p);
82	rb_insert_color(&he->rb_node, root);	82	rb_insert_color(&he->rb_node, root);
83	}	83	}
84		84
85	static void hists__resort_entries(struct hists *self)	85	static void hists__resort_entries(struct hists *self)
86	{	86	{
87	unsigned long position = 1;	87	unsigned long position = 1;
88	struct rb_root tmp = RB_ROOT;	88	struct rb_root tmp = RB_ROOT;
89	struct rb_node *next = rb_first(&self->entries);	89	struct rb_node *next = rb_first(&self->entries);
90		90
91	while (next != NULL) {	91	while (next != NULL) {
92	struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);	92	struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
93		93
94	next = rb_next(&n->rb_node);	94	next = rb_next(&n->rb_node);
95	rb_erase(&n->rb_node, &self->entries);	95	rb_erase(&n->rb_node, &self->entries);
96	n->position = position++;	96	n->position = position++;
97	perf_session__insert_hist_entry_by_name(&tmp, n);	97	perf_session__insert_hist_entry_by_name(&tmp, n);
98	}	98	}
99		99
100	self->entries = tmp;	100	self->entries = tmp;
101	}	101	}
102		102
103	static void hists__set_positions(struct hists *self)	103	static void hists__set_positions(struct hists *self)
104	{	104	{
105	hists__output_resort(self);	105	hists__output_resort(self);
106	hists__resort_entries(self);	106	hists__resort_entries(self);
107	}	107	}
108		108
109	static struct hist_entry hists__find_entry(struct hists self,	109	static struct hist_entry hists__find_entry(struct hists self,
110	struct hist_entry *he)	110	struct hist_entry *he)
111	{	111	{
112	struct rb_node *n = self->entries.rb_node;	112	struct rb_node *n = self->entries.rb_node;
113		113
114	while (n) {	114	while (n) {
115	struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);	115	struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
116	int64_t cmp = hist_entry__cmp(he, iter);	116	int64_t cmp = hist_entry__cmp(he, iter);
117		117
118	if (cmp < 0)	118	if (cmp < 0)
119	n = n->rb_left;	119	n = n->rb_left;
120	else if (cmp > 0)	120	else if (cmp > 0)
121	n = n->rb_right;	121	n = n->rb_right;
122	else	122	else
123	return iter;	123	return iter;
124	}	124	}
125		125
126	return NULL;	126	return NULL;
127	}	127	}
128		128
129	static void hists__match(struct hists older, struct hists newer)	129	static void hists__match(struct hists older, struct hists newer)
130	{	130	{
131	struct rb_node *nd;	131	struct rb_node *nd;
132		132
133	for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {	133	for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {
134	struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);	134	struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
135	pos->pair = hists__find_entry(older, pos);	135	pos->pair = hists__find_entry(older, pos);
136	}	136	}
137	}	137	}
138		138
139	static int __cmd_diff(void)	139	static int __cmd_diff(void)
140	{	140	{
141	int ret, i;	141	int ret, i;
142	struct perf_session *session[2];	142	struct perf_session *session[2];
143		143
144	session[0] = perf_session__new(input_old, O_RDONLY, force, false);	144	session[0] = perf_session__new(input_old, O_RDONLY, force, false);
145	session[1] = perf_session__new(input_new, O_RDONLY, force, false);	145	session[1] = perf_session__new(input_new, O_RDONLY, force, false);
146	if (session[0] == NULL \|\| session[1] == NULL)	146	if (session[0] == NULL \|\| session[1] == NULL)
147	return -ENOMEM;	147	return -ENOMEM;
148		148
149	for (i = 0; i < 2; ++i) {	149	for (i = 0; i < 2; ++i) {
150	ret = perf_session__process_events(session[i], &event_ops);	150	ret = perf_session__process_events(session[i], &event_ops);
151	if (ret)	151	if (ret)
152	goto out_delete;	152	goto out_delete;
153	}	153	}
154		154
155	hists__output_resort(&session[1]->hists);	155	hists__output_resort(&session[1]->hists);
156	if (show_displacement)	156	if (show_displacement)
157	hists__set_positions(&session[0]->hists);	157	hists__set_positions(&session[0]->hists);
158		158
159	hists__match(&session[0]->hists, &session[1]->hists);	159	hists__match(&session[0]->hists, &session[1]->hists);
160	hists__fprintf(&session[1]->hists, &session[0]->hists,	160	hists__fprintf(&session[1]->hists, &session[0]->hists,
161	show_displacement, stdout);	161	show_displacement, stdout);
162	out_delete:	162	out_delete:
163	for (i = 0; i < 2; ++i)	163	for (i = 0; i < 2; ++i)
164	perf_session__delete(session[i]);	164	perf_session__delete(session[i]);
165	return ret;	165	return ret;
166	}	166	}
167		167
168	static const char * const diff_usage[] = {	168	static const char * const diff_usage[] = {
169	"perf diff [<options>] [old_file] [new_file]",	169	"perf diff [<options>] [old_file] [new_file]",
170	NULL,	170	NULL,
171	};	171	};
172		172
173	static const struct option options[] = {	173	static const struct option options[] = {
174	OPT_INCR('v', "verbose", &verbose,	174	OPT_INCR('v', "verbose", &verbose,
175	"be more verbose (show symbol address, etc)"),	175	"be more verbose (show symbol address, etc)"),
176	OPT_BOOLEAN('m', "displacement", &show_displacement,	176	OPT_BOOLEAN('M', "displacement", &show_displacement,
177	"Show position displacement relative to baseline"),	177	"Show position displacement relative to baseline"),
178	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,	178	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
179	"dump raw trace in ASCII"),	179	"dump raw trace in ASCII"),
180	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),	180	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
181	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,	181	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
182	"load module symbols - WARNING: use only with -k and LIVE kernel"),	182	"load module symbols - WARNING: use only with -k and LIVE kernel"),
183	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",	183	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
184	"only consider symbols in these dsos"),	184	"only consider symbols in these dsos"),
185	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",	185	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
186	"only consider symbols in these comms"),	186	"only consider symbols in these comms"),
187	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",	187	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
188	"only consider these symbols"),	188	"only consider these symbols"),
189	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",	189	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
190	"sort by key(s): pid, comm, dso, symbol, parent"),	190	"sort by key(s): pid, comm, dso, symbol, parent"),
191	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",	191	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
192	"separator for columns, no spaces will be added between "	192	"separator for columns, no spaces will be added between "
193	"columns '.' is reserved."),	193	"columns '.' is reserved."),
194	OPT_END()	194	OPT_END()
195	};	195	};
196		196
197	int cmd_diff(int argc, const char *argv, const char prefix __used)	197	int cmd_diff(int argc, const char *argv, const char prefix __used)
198	{	198	{
199	sort_order = diff__default_sort_order;	199	sort_order = diff__default_sort_order;
200	argc = parse_options(argc, argv, options, diff_usage, 0);	200	argc = parse_options(argc, argv, options, diff_usage, 0);
201	if (argc) {	201	if (argc) {
202	if (argc > 2)	202	if (argc > 2)
203	usage_with_options(diff_usage, options);	203	usage_with_options(diff_usage, options);
204	if (argc == 2) {	204	if (argc == 2) {
205	input_old = argv[0];	205	input_old = argv[0];
206	input_new = argv[1];	206	input_new = argv[1];
207	} else	207	} else
208	input_new = argv[0];	208	input_new = argv[0];
209	} else if (symbol_conf.default_guest_vmlinux_name \|\|	209	} else if (symbol_conf.default_guest_vmlinux_name \|\|
210	symbol_conf.default_guest_kallsyms) {	210	symbol_conf.default_guest_kallsyms) {
211	input_old = "perf.data.host";	211	input_old = "perf.data.host";
212	input_new = "perf.data.guest";	212	input_new = "perf.data.guest";
213	}	213	}
214		214
215	symbol_conf.exclude_other = false;	215	symbol_conf.exclude_other = false;
216	if (symbol__init() < 0)	216	if (symbol__init() < 0)
217	return -1;	217	return -1;
218		218
219	setup_sorting(diff_usage, options);	219	setup_sorting(diff_usage, options);
220	setup_pager();	220	setup_pager();
221		221
222	sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);	222	sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
223	sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);	223	sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
224	sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);	224	sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
225		225
226	return __cmd_diff();	226	return __cmd_diff();
227	}	227	}
228		228

tools/perf/builtin-stat.c

Diff comments View file @ e4b546a

 /*
  * builtin-stat.c
  *
  * Builtin stat command: Give a precise performance counters summary
  * overview about any workload, CPU or specific PID.
  *
  * Sample output:
    $ perf stat ~/hackbench 10
    Time: 0.104
     Performance counter stats for '/home/mingo/hackbench':
        1255.538611  task clock ticks     #      10.143 CPU utilization factor
              54011  context switches     #       0.043 M/sec
                385  CPU migrations       #       0.000 M/sec
              17755  pagefaults           #       0.014 M/sec
         3808323185  CPU cycles           #    3033.219 M/sec
         1575111190  instructions         #    1254.530 M/sec
           17367895  cache references     #      13.833 M/sec
            7674421  cache misses         #       6.112 M/sec
     Wall-clock time elapsed:   123.786620 msecs
  *
  * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  *
  * Improvements and fixes by:
  *
  *   Arjan van de Ven <arjan@linux.intel.com>
  *   Yanmin Zhang <yanmin.zhang@intel.com>
  *   Wu Fengguang <fengguang.wu@intel.com>
  *   Mike Galbraith <efault@gmx.de>
  *   Paul Mackerras <paulus@samba.org>
  *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "perf.h"
 #include "builtin.h"
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/event.h"
 #include "util/debug.h"
 #include "util/header.h"
 #include "util/cpumap.h"
 #include "util/thread.h"
 #include <sys/prctl.h>
 #include <math.h>
 #include <locale.h>
+#define DEFAULT_SEPARATOR	" "
 static struct perf_event_attr default_attrs[] = {
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK		},
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES	},
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS		},
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS		},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES		},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS		},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS	},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES		},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES	},
   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES		},
 };
 static bool			system_wide			=  false;
 static int			nr_cpus				=  0;
 static int			run_idx				=  0;
 static int			run_count			=  1;
 static bool			no_inherit			= false;
 static bool			scale				=  true;
 static bool			no_aggr				= false;
 static pid_t			target_pid			= -1;
 static pid_t			target_tid			= -1;
 static pid_t			*all_tids			=  NULL;
 static int			thread_num			=  0;
 static pid_t			child_pid			= -1;
 static bool			null_run			=  false;
-static bool			big_num				=  false;
+static bool			big_num				=  true;
+static int			big_num_opt			=  -1;
 static const char		*cpu_list;
+static const char		*csv_sep			= NULL;
+static bool			csv_output			= false;
 static int			*fd[MAX_NR_CPUS][MAX_COUNTERS];
 static int			event_scaled[MAX_COUNTERS];
 static struct {
 	u64 val;
 	u64 ena;
 	u64 run;
 } cpu_counts[MAX_NR_CPUS][MAX_COUNTERS];
 static volatile int done = 0;
 struct stats
 {
 	double n, mean, M2;
 };
 static void update_stats(struct stats *stats, u64 val)
 {
 	double delta;
 	stats->n++;
 	delta = val - stats->mean;
 	stats->mean += delta / stats->n;
 	stats->M2 += delta*(val - stats->mean);
 }
 static double avg_stats(struct stats *stats)
 {
 	return stats->mean;
 }
 /*
  * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
  *
  *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
  * s^2 = -------------------------------
  *                  n - 1
  *
  * http://en.wikipedia.org/wiki/Stddev
  *
  * The std dev of the mean is related to the std dev by:
  *
  *             s
  * s_mean = -------
  *          sqrt(n)
  *
  */
 static double stddev_stats(struct stats *stats)
 {
 	double variance = stats->M2 / (stats->n - 1);
 	double variance_mean = variance / stats->n;
 	return sqrt(variance_mean);
 }
 struct stats			event_res_stats[MAX_COUNTERS][3];
 struct stats			runtime_nsecs_stats[MAX_NR_CPUS];
 struct stats			runtime_cycles_stats[MAX_NR_CPUS];
 struct stats			runtime_branches_stats[MAX_NR_CPUS];
 struct stats			walltime_nsecs_stats;
 #define MATCH_EVENT(t, c, counter)			\
 	(attrs[counter].type == PERF_TYPE_##t &&	\
 	 attrs[counter].config == PERF_COUNT_##c)
 #define ERR_PERF_OPEN \
 "counter %d, sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information."
 static int create_perf_stat_counter(int counter, bool *perm_err)
 {
 	struct perf_event_attr *attr = attrs + counter;
 	int thread;
 	int ncreated = 0;
 	if (scale)
 		attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 				    PERF_FORMAT_TOTAL_TIME_RUNNING;
 	if (system_wide) {
 		int cpu;
 		for (cpu = 0; cpu < nr_cpus; cpu++) {
 			fd[cpu][counter][0] = sys_perf_event_open(attr,
 					-1, cpumap[cpu], -1, 0);
 			if (fd[cpu][counter][0] < 0) {
 				if (errno == EPERM || errno == EACCES)
 					*perm_err = true;
 				error(ERR_PERF_OPEN, counter,
 					 fd[cpu][counter][0], strerror(errno));
 			} else {
 				++ncreated;
 			}
 		}
 	} else {
 		attr->inherit = !no_inherit;
 		if (target_pid == -1 && target_tid == -1) {
 			attr->disabled = 1;
 			attr->enable_on_exec = 1;
 		}
 		for (thread = 0; thread < thread_num; thread++) {
 			fd[0][counter][thread] = sys_perf_event_open(attr,
 				all_tids[thread], -1, -1, 0);
 			if (fd[0][counter][thread] < 0) {
 				if (errno == EPERM || errno == EACCES)
 					*perm_err = true;
 				error(ERR_PERF_OPEN, counter,
 					 fd[0][counter][thread],
 					 strerror(errno));
 			} else {
 				++ncreated;
 			}
 		}
 	}
 	return ncreated;
 }
 /*
  * Does the counter have nsecs as a unit?
  */
 static inline int nsec_counter(int counter)
 {
 	if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
 	    MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
 		return 1;
 	return 0;
 }
 /*
  * Read out the results of a single counter:
  * aggregate counts across CPUs in system-wide mode
  */
 static void read_counter_aggr(int counter)
 {
 	u64 count[3], single_count[3];
 	int cpu;
 	size_t res, nv;
 	int scaled;
 	int i, thread;
 	count[0] = count[1] = count[2] = 0;
 	nv = scale ? 3 : 1;
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		for (thread = 0; thread < thread_num; thread++) {
 			if (fd[cpu][counter][thread] < 0)
 				continue;
 			res = read(fd[cpu][counter][thread],
 					single_count, nv * sizeof(u64));
 			assert(res == nv * sizeof(u64));
 			close(fd[cpu][counter][thread]);
 			fd[cpu][counter][thread] = -1;
 			count[0] += single_count[0];
 			if (scale) {
 				count[1] += single_count[1];
 				count[2] += single_count[2];
 			}
 		}
 	}
 	scaled = 0;
 	if (scale) {
 		if (count[2] == 0) {
 			event_scaled[counter] = -1;
 			count[0] = 0;
 			return;
 		}
 		if (count[2] < count[1]) {
 			event_scaled[counter] = 1;
 			count[0] = (unsigned long long)
 				((double)count[0] * count[1] / count[2] + 0.5);
 		}
 	}
 	for (i = 0; i < 3; i++)
 		update_stats(&event_res_stats[counter][i], count[i]);
 	if (verbose) {
 		fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
 				count[0], count[1], count[2]);
 	}
 	/*
 	 * Save the full runtime - to allow normalization during printout:
 	 */
 	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
 		update_stats(&runtime_nsecs_stats[0], count[0]);
 	if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
 		update_stats(&runtime_cycles_stats[0], count[0]);
 	if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
 		update_stats(&runtime_branches_stats[0], count[0]);
 }
 /*
  * Read out the results of a single counter:
  * do not aggregate counts across CPUs in system-wide mode
  */
 static void read_counter(int counter)
 {
 	u64 count[3];
 	int cpu;
 	size_t res, nv;
 	count[0] = count[1] = count[2] = 0;
 	nv = scale ? 3 : 1;
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		if (fd[cpu][counter][0] < 0)
 			continue;
 		res = read(fd[cpu][counter][0], count, nv * sizeof(u64));
 		assert(res == nv * sizeof(u64));
 		close(fd[cpu][counter][0]);
 		fd[cpu][counter][0] = -1;
 		if (scale) {
 			if (count[2] == 0) {
 				count[0] = 0;
 			} else if (count[2] < count[1]) {
 				count[0] = (unsigned long long)
 				((double)count[0] * count[1] / count[2] + 0.5);
 			}
 		}
 		cpu_counts[cpu][counter].val = count[0]; /* scaled count */
 		cpu_counts[cpu][counter].ena = count[1];
 		cpu_counts[cpu][counter].run = count[2];
 		if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
 			update_stats(&runtime_nsecs_stats[cpu], count[0]);
 		if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
 			update_stats(&runtime_cycles_stats[cpu], count[0]);
 		if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
 			update_stats(&runtime_branches_stats[cpu], count[0]);
 	}
 }
 static int run_perf_stat(int argc __used, const char **argv)
 {
 	unsigned long long t0, t1;
 	int status = 0;
 	int counter, ncreated = 0;
 	int child_ready_pipe[2], go_pipe[2];
 	bool perm_err = false;
 	const bool forks = (argc > 0);
 	char buf;
 	if (!system_wide)
 		nr_cpus = 1;
 	if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 		perror("failed to create pipes");
 		exit(1);
 	}
 	if (forks) {
 		if ((child_pid = fork()) < 0)
 			perror("failed to fork");
 		if (!child_pid) {
 			close(child_ready_pipe[0]);
 			close(go_pipe[1]);
 			fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 			/*
 			 * Do a dummy execvp to get the PLT entry resolved,
 			 * so we avoid the resolver overhead on the real
 			 * execvp call.
 			 */
 			execvp("", (char **)argv);
 			/*
 			 * Tell the parent we're ready to go
 			 */
 			close(child_ready_pipe[1]);
 			/*
 			 * Wait until the parent tells us to go.
 			 */
 			if (read(go_pipe[0], &buf, 1) == -1)
 				perror("unable to read pipe");
 			execvp(argv[0], (char **)argv);
 			perror(argv[0]);
 			exit(-1);
 		}
 		if (target_tid == -1 && target_pid == -1 && !system_wide)
 			all_tids[0] = child_pid;
 		/*
 		 * Wait for the child to be ready to exec.
 		 */
 		close(child_ready_pipe[1]);
 		close(go_pipe[0]);
 		if (read(child_ready_pipe[0], &buf, 1) == -1)
 			perror("unable to read pipe");
 		close(child_ready_pipe[0]);
 	}
 	for (counter = 0; counter < nr_counters; counter++)
 		ncreated += create_perf_stat_counter(counter, &perm_err);
 	if (ncreated < nr_counters) {
 		if (perm_err)
 			error("You may not have permission to collect %sstats.\n"
 			      "\t Consider tweaking"
 			      " /proc/sys/kernel/perf_event_paranoid or running as root.",
 			      system_wide ? "system-wide " : "");
 		die("Not all events could be opened.\n");
 		if (child_pid != -1)
 			kill(child_pid, SIGTERM);
 		return -1;
 	}
 	/*
 	 * Enable counters and exec the command:
 	 */
 	t0 = rdclock();
 	if (forks) {
 		close(go_pipe[1]);
 		wait(&status);
 	} else {
 		while(!done) sleep(1);
 	}
 	t1 = rdclock();
 	update_stats(&walltime_nsecs_stats, t1 - t0);
 	if (no_aggr) {
 		for (counter = 0; counter < nr_counters; counter++)
 			read_counter(counter);
 	} else {
 		for (counter = 0; counter < nr_counters; counter++)
 			read_counter_aggr(counter);
 	}
 	return WEXITSTATUS(status);
 }
 static void print_noise(int counter, double avg)
 {
 	if (run_count == 1)
 		return;
 	fprintf(stderr, "   ( +- %7.3f%% )",
 			100 * stddev_stats(&event_res_stats[counter][0]) / avg);
 }
 static void nsec_printout(int cpu, int counter, double avg)
 {
 	double msecs = avg / 1e6;
+	char cpustr[16] = { '\0', };
+	const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-24s";
 	if (no_aggr)
-		fprintf(stderr, "CPU%-4d %18.6f  %-24s",
+		sprintf(cpustr, "CPU%*d%s",
-			cpumap[cpu], msecs, event_name(counter));
+			csv_output ? 0 : -4,
-	else
+			cpumap[cpu], csv_sep);
-		fprintf(stderr, " %18.6f  %-24s", msecs, event_name(counter));
+	fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(counter));
+	if (csv_output)
+		return;
 	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
 		fprintf(stderr, " # %10.3f CPUs ",
 				avg / avg_stats(&walltime_nsecs_stats));
 	}
 }
 static void abs_printout(int cpu, int counter, double avg)
 {
 	double total, ratio = 0.0;
 	char cpustr[16] = { '\0', };
+	const char *fmt;
+	if (csv_output)
+		fmt = "%s%.0f%s%s";
+	else if (big_num)
+		fmt = "%s%'18.0f%s%-24s";
+	else
+		fmt = "%s%18.0f%s%-24s";
 	if (no_aggr)
-		sprintf(cpustr, "CPU%-4d", cpumap[cpu]);
+		sprintf(cpustr, "CPU%*d%s",
+			csv_output ? 0 : -4,
+			cpumap[cpu], csv_sep);
 	else
 		cpu = 0;
-	if (big_num)
+	fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(counter));
-		fprintf(stderr, "%s %'18.0f  %-24s",
-			cpustr, avg, event_name(counter));
-	else
-		fprintf(stderr, "%s %18.0f  %-24s",
-			cpustr, avg, event_name(counter));
+	if (csv_output)
+		return;
 	if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
 		total = avg_stats(&runtime_cycles_stats[cpu]);
 		if (total)
 			ratio = avg / total;
 		fprintf(stderr, " # %10.3f IPC  ", ratio);
 	} else if (MATCH_EVENT(HARDWARE, HW_BRANCH_MISSES, counter) &&
 			runtime_branches_stats[cpu].n != 0) {
 		total = avg_stats(&runtime_branches_stats[cpu]);
 		if (total)
 			ratio = avg * 100 / total;
 		fprintf(stderr, " # %10.3f %%    ", ratio);
 	} else if (runtime_nsecs_stats[cpu].n != 0) {
 		total = avg_stats(&runtime_nsecs_stats[cpu]);
 		if (total)
 			ratio = 1000.0 * avg / total;
 		fprintf(stderr, " # %10.3f M/sec", ratio);
 	}
 }
 /*
  * Print out the results of a single counter:
  * aggregated counts in system-wide mode
  */
 static void print_counter_aggr(int counter)
 {
 	double avg = avg_stats(&event_res_stats[counter][0]);
 	int scaled = event_scaled[counter];
 	if (scaled == -1) {
-		fprintf(stderr, " %18s  %-24s\n",
+		fprintf(stderr, "%*s%s%-24s\n",
-			"<not counted>", event_name(counter));
+			csv_output ? 0 : 18,
+			"<not counted>", csv_sep, event_name(counter));
 		return;
 	}
 	if (nsec_counter(counter))
 		nsec_printout(-1, counter, avg);
 	else
 		abs_printout(-1, counter, avg);
+	if (csv_output) {
+		fputc('\n', stderr);
+		return;
+	}
 	print_noise(counter, avg);
 	if (scaled) {
 		double avg_enabled, avg_running;
 		avg_enabled = avg_stats(&event_res_stats[counter][1]);
 		avg_running = avg_stats(&event_res_stats[counter][2]);
 		fprintf(stderr, "  (scaled from %.2f%%)",
 				100 * avg_running / avg_enabled);
 	}
 	fprintf(stderr, "\n");
 }
 /*
  * Print out the results of a single counter:
  * does not use aggregated count in system-wide
  */
 static void print_counter(int counter)
 {
 	u64 ena, run, val;
 	int cpu;
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		val = cpu_counts[cpu][counter].val;
 		ena = cpu_counts[cpu][counter].ena;
 		run = cpu_counts[cpu][counter].run;
 		if (run == 0 || ena == 0) {
-			fprintf(stderr, "CPU%-4d %18s  %-24s", cpumap[cpu],
+			fprintf(stderr, "CPU%*d%s%*s%s%-24s",
-					"<not counted>", event_name(counter));
+				csv_output ? 0 : -4,
+				cpumap[cpu], csv_sep,
+				csv_output ? 0 : 18,
+				"<not counted>", csv_sep,
+				event_name(counter));
 			fprintf(stderr, "\n");
 			continue;
 		}
 		if (nsec_counter(counter))
 			nsec_printout(cpu, counter, val);
 		else
 			abs_printout(cpu, counter, val);
-		print_noise(counter, 1.0);
+		if (!csv_output) {
+			print_noise(counter, 1.0);
-		if (run != ena) {
+			if (run != ena) {
-			fprintf(stderr, "  (scaled from %.2f%%)",
+				fprintf(stderr, "  (scaled from %.2f%%)",
 					100.0 * run / ena);
+			}
 		}
 		fprintf(stderr, "\n");
 	}
 }
 static void print_stat(int argc, const char **argv)
 {
 	int i, counter;
 	fflush(stdout);
-	fprintf(stderr, "\n");
+	if (!csv_output) {
-	fprintf(stderr, " Performance counter stats for ");
+		fprintf(stderr, "\n");
-	if(target_pid == -1 && target_tid == -1) {
+		fprintf(stderr, " Performance counter stats for ");
-		fprintf(stderr, "\'%s", argv[0]);
+		if(target_pid == -1 && target_tid == -1) {
-		for (i = 1; i < argc; i++)
+			fprintf(stderr, "\'%s", argv[0]);
-			fprintf(stderr, " %s", argv[i]);
+			for (i = 1; i < argc; i++)
-	} else if (target_pid != -1)
+				fprintf(stderr, " %s", argv[i]);
-		fprintf(stderr, "process id \'%d", target_pid);
+		} else if (target_pid != -1)
-	else
+			fprintf(stderr, "process id \'%d", target_pid);
-		fprintf(stderr, "thread id \'%d", target_tid);
+		else
+			fprintf(stderr, "thread id \'%d", target_tid);
-	fprintf(stderr, "\'");
+		fprintf(stderr, "\'");
-	if (run_count > 1)
+		if (run_count > 1)
-		fprintf(stderr, " (%d runs)", run_count);
+			fprintf(stderr, " (%d runs)", run_count);
-	fprintf(stderr, ":\n\n");
+		fprintf(stderr, ":\n\n");
+	}
 	if (no_aggr) {
 		for (counter = 0; counter < nr_counters; counter++)
 			print_counter(counter);
 	} else {
 		for (counter = 0; counter < nr_counters; counter++)
 			print_counter_aggr(counter);
 	}
-	fprintf(stderr, "\n");
+	if (!csv_output) {
-	fprintf(stderr, " %18.9f  seconds time elapsed",
+		fprintf(stderr, "\n");
-			avg_stats(&walltime_nsecs_stats)/1e9);
+		fprintf(stderr, " %18.9f  seconds time elapsed",
-	if (run_count > 1) {
+				avg_stats(&walltime_nsecs_stats)/1e9);
-		fprintf(stderr, "   ( +- %7.3f%% )",
+		if (run_count > 1) {
+			fprintf(stderr, "   ( +- %7.3f%% )",
 				100*stddev_stats(&walltime_nsecs_stats) /
 				avg_stats(&walltime_nsecs_stats));
+		}
+		fprintf(stderr, "\n\n");
 	}
-	fprintf(stderr, "\n\n");
 }
 static volatile int signr = -1;
 static void skip_signal(int signo)
 {
 	if(child_pid == -1)
 		done = 1;
 	signr = signo;
 }
 static void sig_atexit(void)
 {
 	if (child_pid != -1)
 		kill(child_pid, SIGTERM);
 	if (signr == -1)
 		return;
 	signal(signr, SIG_DFL);
 	kill(getpid(), signr);
 }
 static const char * const stat_usage[] = {
 	"perf stat [<options>] [<command>]",
 	NULL
 };
+static int stat__set_big_num(const struct option *opt __used,
+			     const char *s __used, int unset)
+{
+	big_num_opt = unset ? 0 : 1;
+	return 0;
+}
 static const struct option options[] = {
 	OPT_CALLBACK('e', "event", NULL, "event",
 		     "event selector. use 'perf list' to list available events",
 		     parse_events),
 	OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 		    "child tasks do not inherit counters"),
 	OPT_INTEGER('p', "pid", &target_pid,
 		    "stat events on existing process id"),
 	OPT_INTEGER('t', "tid", &target_tid,
 		    "stat events on existing thread id"),
 	OPT_BOOLEAN('a', "all-cpus", &system_wide,
 		    "system-wide collection from all CPUs"),
 	OPT_BOOLEAN('c', "scale", &scale,
 		    "scale/normalize counters"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show counter open errors, etc)"),
 	OPT_INTEGER('r', "repeat", &run_count,
 		    "repeat command and print average + stddev (max: 100)"),
 	OPT_BOOLEAN('n', "null", &null_run,
 		    "null run - dont start any counters"),
-	OPT_BOOLEAN('B', "big-num", &big_num,
+	OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
-		    "print large numbers with thousands\' separators"),
+			   "print large numbers with thousands\' separators",
+			   stat__set_big_num),
 	OPT_STRING('C', "cpu", &cpu_list, "cpu",
 		    "list of cpus to monitor in system-wide"),
 	OPT_BOOLEAN('A', "no-aggr", &no_aggr,
 		    "disable CPU count aggregation"),
+	OPT_STRING('x', "field-separator", &csv_sep, "separator",
+		   "print counts with custom separator"),
 	OPT_END()
 };
 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 {
 	int status;
 	int i,j;
 	setlocale(LC_ALL, "");
 	argc = parse_options(argc, argv, options, stat_usage,
 		PARSE_OPT_STOP_AT_NON_OPTION);
+	if (csv_sep)
+		csv_output = true;
+	else
+		csv_sep = DEFAULT_SEPARATOR;
+	/*
+	 * let the spreadsheet do the pretty-printing
+	 */
+	if (csv_output) {
+		/* User explicitely passed -B? */
+		if (big_num_opt == 1) {
+			fprintf(stderr, "-B option not supported with -x\n");
+			usage_with_options(stat_usage, options);
+		} else /* Nope, so disable big number formatting */
+			big_num = false;
+	} else if (big_num_opt == 0) /* User passed --no-big-num */
+		big_num = false;
 	if (!argc && target_pid == -1 && target_tid == -1)
 		usage_with_options(stat_usage, options);
 	if (run_count <= 0)
 		usage_with_options(stat_usage, options);
 	/* no_aggr is for system-wide only */
 	if (no_aggr && !system_wide)
 		usage_with_options(stat_usage, options);
 	/* Set attrs and nr_counters if no event is selected and !null_run */
 	if (!null_run && !nr_counters) {
 		memcpy(attrs, default_attrs, sizeof(default_attrs));
 		nr_counters = ARRAY_SIZE(default_attrs);
 	}
 	if (system_wide)
 		nr_cpus = read_cpu_map(cpu_list);
 	else
 		nr_cpus = 1;
 	if (nr_cpus < 1)
 		usage_with_options(stat_usage, options);
 	if (target_pid != -1) {
 		target_tid = target_pid;
 		thread_num = find_all_tid(target_pid, &all_tids);
 		if (thread_num <= 0) {
 			fprintf(stderr, "Can't find all threads of pid %d\n",
 					target_pid);
 			usage_with_options(stat_usage, options);
 		}
 	} else {
 		all_tids=malloc(sizeof(pid_t));
 		if (!all_tids)
 			return -ENOMEM;
 		all_tids[0] = target_tid;
 		thread_num = 1;
 	}
 	for (i = 0; i < MAX_NR_CPUS; i++) {
 		for (j = 0; j < MAX_COUNTERS; j++) {
 			fd[i][j] = malloc(sizeof(int)*thread_num);
 			if (!fd[i][j])
 				return -ENOMEM;
 		}
 	}
 	/*
 	 * We dont want to block the signals - that would cause
 	 * child tasks to inherit that and Ctrl-C would not work.
 	 * What we want is for Ctrl-C to work in the exec()-ed
 	 * task, but being ignored by perf stat itself:
 	 */
 	atexit(sig_atexit);
 	signal(SIGINT,  skip_signal);
 	signal(SIGALRM, skip_signal);
 	signal(SIGABRT, skip_signal);
 	status = 0;
 	for (run_idx = 0; run_idx < run_count; run_idx++) {
 		if (run_count != 1 && verbose)
 			fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
 		status = run_perf_stat(argc, argv);
 	}