License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-12-14 22:09:31 +00:00
|
|
|
/*
|
|
|
|
* builtin-diff.c
|
|
|
|
*
|
|
|
|
* Builtin diff command: Analyze two perf.data input files, look up and read
|
|
|
|
* DSOs and symbol information, sort them and produce a diff.
|
|
|
|
*/
|
|
|
|
#include "builtin.h"
|
|
|
|
|
|
|
|
#include "util/debug.h"
|
|
|
|
#include "util/event.h"
|
|
|
|
#include "util/hist.h"
|
2011-11-28 09:56:39 +00:00
|
|
|
#include "util/evsel.h"
|
2012-09-06 15:46:55 +00:00
|
|
|
#include "util/evlist.h"
|
2009-12-14 22:09:31 +00:00
|
|
|
#include "util/session.h"
|
2011-11-28 10:30:20 +00:00
|
|
|
#include "util/tool.h"
|
2009-12-14 22:09:31 +00:00
|
|
|
#include "util/sort.h"
|
2019-08-22 20:10:08 +00:00
|
|
|
#include "util/srcline.h"
|
2009-12-14 22:09:31 +00:00
|
|
|
#include "util/symbol.h"
|
2013-10-15 14:27:32 +00:00
|
|
|
#include "util/data.h"
|
2017-02-10 07:36:12 +00:00
|
|
|
#include "util/config.h"
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
#include "util/time-utils.h"
|
2019-06-28 09:23:01 +00:00
|
|
|
#include "util/annotate.h"
|
2019-06-28 09:23:03 +00:00
|
|
|
#include "util/map.h"
|
2019-09-25 01:14:46 +00:00
|
|
|
#include "util/spark.h"
|
2019-11-07 07:47:14 +00:00
|
|
|
#include "util/block-info.h"
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
#include "util/stream.h"
|
2023-04-10 16:25:11 +00:00
|
|
|
#include "util/util.h"
|
2019-08-22 07:20:49 +00:00
|
|
|
#include <linux/err.h>
|
2019-07-04 14:32:27 +00:00
|
|
|
#include <linux/zalloc.h>
|
2019-08-29 19:18:59 +00:00
|
|
|
#include <subcmd/pager.h>
|
2019-08-22 20:10:08 +00:00
|
|
|
#include <subcmd/parse-options.h>
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2017-04-18 13:46:11 +00:00
|
|
|
#include <errno.h>
|
2017-04-17 18:23:08 +00:00
|
|
|
#include <inttypes.h>
|
2009-12-14 22:09:31 +00:00
|
|
|
#include <stdlib.h>
|
2013-02-03 19:08:34 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
struct perf_diff {
|
|
|
|
struct perf_tool tool;
|
|
|
|
const char *time_str;
|
|
|
|
struct perf_time_interval *ptime_range;
|
|
|
|
int range_size;
|
|
|
|
int range_num;
|
2019-06-28 09:23:00 +00:00
|
|
|
bool has_br_stack;
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
bool stream;
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
};
|
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
/* Diff command specific HPP columns. */
|
|
|
|
enum {
|
|
|
|
PERF_HPP_DIFF__BASELINE,
|
|
|
|
PERF_HPP_DIFF__PERIOD,
|
|
|
|
PERF_HPP_DIFF__PERIOD_BASELINE,
|
|
|
|
PERF_HPP_DIFF__DELTA,
|
|
|
|
PERF_HPP_DIFF__RATIO,
|
|
|
|
PERF_HPP_DIFF__WEIGHTED_DIFF,
|
|
|
|
PERF_HPP_DIFF__FORMULA,
|
2017-02-10 07:36:11 +00:00
|
|
|
PERF_HPP_DIFF__DELTA_ABS,
|
2019-06-28 09:23:03 +00:00
|
|
|
PERF_HPP_DIFF__CYCLES,
|
2019-09-25 01:14:46 +00:00
|
|
|
PERF_HPP_DIFF__CYCLES_HIST,
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
PERF_HPP_DIFF__MAX_INDEX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct diff_hpp_fmt {
|
|
|
|
struct perf_hpp_fmt fmt;
|
|
|
|
int idx;
|
|
|
|
char *header;
|
|
|
|
int header_width;
|
|
|
|
};
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
struct data__file {
|
|
|
|
struct perf_session *session;
|
2017-01-23 21:07:59 +00:00
|
|
|
struct perf_data data;
|
2013-03-24 23:02:01 +00:00
|
|
|
int idx;
|
2012-12-01 21:00:00 +00:00
|
|
|
struct hists *hists;
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
struct evlist_streams *evlist_streams;
|
2012-12-01 20:57:04 +00:00
|
|
|
struct diff_hpp_fmt fmt[PERF_HPP_DIFF__MAX_INDEX];
|
2013-03-24 23:02:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct data__file *data__files;
|
|
|
|
static int data__files_cnt;
|
|
|
|
|
|
|
|
#define data__for_each_file_start(i, d, s) \
|
|
|
|
for (i = s, d = &data__files[s]; \
|
|
|
|
i < data__files_cnt; \
|
|
|
|
i++, d = &data__files[i])
|
|
|
|
|
|
|
|
#define data__for_each_file(i, d) data__for_each_file_start(i, d, 0)
|
2012-12-01 21:00:00 +00:00
|
|
|
#define data__for_each_file_new(i, d) data__for_each_file_start(i, d, 1)
|
2013-03-24 23:02:01 +00:00
|
|
|
|
|
|
|
static bool force;
|
2012-10-05 14:44:44 +00:00
|
|
|
static bool show_period;
|
2012-10-05 14:44:45 +00:00
|
|
|
static bool show_formula;
|
2012-10-05 14:44:40 +00:00
|
|
|
static bool show_baseline_only;
|
2019-09-25 01:14:46 +00:00
|
|
|
static bool cycles_hist;
|
2017-02-10 16:18:56 +00:00
|
|
|
static unsigned int sort_compute = 1;
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2012-10-05 14:44:43 +00:00
|
|
|
static s64 compute_wdiff_w1;
|
|
|
|
static s64 compute_wdiff_w2;
|
|
|
|
|
2019-03-05 13:05:42 +00:00
|
|
|
static const char *cpu_list;
|
|
|
|
static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
|
|
|
|
|
2012-10-05 14:44:41 +00:00
|
|
|
enum {
|
|
|
|
COMPUTE_DELTA,
|
|
|
|
COMPUTE_RATIO,
|
2012-10-05 14:44:43 +00:00
|
|
|
COMPUTE_WEIGHTED_DIFF,
|
2017-02-10 07:36:11 +00:00
|
|
|
COMPUTE_DELTA_ABS,
|
2019-06-28 09:23:01 +00:00
|
|
|
COMPUTE_CYCLES,
|
2012-10-05 14:44:41 +00:00
|
|
|
COMPUTE_MAX,
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
COMPUTE_STREAM, /* After COMPUTE_MAX to avoid use current compute arrays */
|
2012-10-05 14:44:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
const char *compute_names[COMPUTE_MAX] = {
|
|
|
|
[COMPUTE_DELTA] = "delta",
|
2017-02-10 07:36:11 +00:00
|
|
|
[COMPUTE_DELTA_ABS] = "delta-abs",
|
2012-10-05 14:44:41 +00:00
|
|
|
[COMPUTE_RATIO] = "ratio",
|
2012-10-05 14:44:43 +00:00
|
|
|
[COMPUTE_WEIGHTED_DIFF] = "wdiff",
|
2019-06-28 09:23:01 +00:00
|
|
|
[COMPUTE_CYCLES] = "cycles",
|
2012-10-05 14:44:41 +00:00
|
|
|
};
|
|
|
|
|
2017-02-10 16:18:56 +00:00
|
|
|
static int compute = COMPUTE_DELTA_ABS;
|
2012-10-05 14:44:41 +00:00
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
static int compute_2_hpp[COMPUTE_MAX] = {
|
|
|
|
[COMPUTE_DELTA] = PERF_HPP_DIFF__DELTA,
|
2017-02-10 07:36:11 +00:00
|
|
|
[COMPUTE_DELTA_ABS] = PERF_HPP_DIFF__DELTA_ABS,
|
2013-02-03 19:08:34 +00:00
|
|
|
[COMPUTE_RATIO] = PERF_HPP_DIFF__RATIO,
|
|
|
|
[COMPUTE_WEIGHTED_DIFF] = PERF_HPP_DIFF__WEIGHTED_DIFF,
|
2019-06-28 09:23:03 +00:00
|
|
|
[COMPUTE_CYCLES] = PERF_HPP_DIFF__CYCLES,
|
2013-02-03 19:08:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define MAX_COL_WIDTH 70
|
|
|
|
|
|
|
|
static struct header_column {
|
|
|
|
const char *name;
|
|
|
|
int width;
|
|
|
|
} columns[PERF_HPP_DIFF__MAX_INDEX] = {
|
|
|
|
[PERF_HPP_DIFF__BASELINE] = {
|
|
|
|
.name = "Baseline",
|
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__PERIOD] = {
|
|
|
|
.name = "Period",
|
|
|
|
.width = 14,
|
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__PERIOD_BASELINE] = {
|
|
|
|
.name = "Base period",
|
|
|
|
.width = 14,
|
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__DELTA] = {
|
|
|
|
.name = "Delta",
|
|
|
|
.width = 7,
|
|
|
|
},
|
2017-02-10 07:36:11 +00:00
|
|
|
[PERF_HPP_DIFF__DELTA_ABS] = {
|
|
|
|
.name = "Delta Abs",
|
|
|
|
.width = 7,
|
|
|
|
},
|
2013-02-03 19:08:34 +00:00
|
|
|
[PERF_HPP_DIFF__RATIO] = {
|
|
|
|
.name = "Ratio",
|
|
|
|
.width = 14,
|
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__WEIGHTED_DIFF] = {
|
|
|
|
.name = "Weighted diff",
|
|
|
|
.width = 14,
|
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__FORMULA] = {
|
|
|
|
.name = "Formula",
|
|
|
|
.width = MAX_COL_WIDTH,
|
2019-06-28 09:23:03 +00:00
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__CYCLES] = {
|
|
|
|
.name = "[Program Block Range] Cycles Diff",
|
|
|
|
.width = 70,
|
2019-09-25 01:14:46 +00:00
|
|
|
},
|
|
|
|
[PERF_HPP_DIFF__CYCLES_HIST] = {
|
|
|
|
.name = "stddev/Hist",
|
|
|
|
.width = NUM_SPARKS + 9,
|
2013-02-03 19:08:34 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-10-05 14:44:43 +00:00
|
|
|
static int setup_compute_opt_wdiff(char *opt)
|
|
|
|
{
|
|
|
|
char *w1_str = opt;
|
|
|
|
char *w2_str;
|
|
|
|
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
if (!opt)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
w2_str = strchr(opt, ',');
|
|
|
|
if (!w2_str)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
*w2_str++ = 0x0;
|
|
|
|
if (!*w2_str)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
compute_wdiff_w1 = strtol(w1_str, NULL, 10);
|
|
|
|
compute_wdiff_w2 = strtol(w2_str, NULL, 10);
|
|
|
|
|
|
|
|
if (!compute_wdiff_w1 || !compute_wdiff_w2)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n",
|
|
|
|
compute_wdiff_w1, compute_wdiff_w2);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (ret)
|
|
|
|
pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_compute_opt(char *opt)
|
|
|
|
{
|
|
|
|
if (compute == COMPUTE_WEIGHTED_DIFF)
|
|
|
|
return setup_compute_opt_wdiff(opt);
|
|
|
|
|
|
|
|
if (opt) {
|
|
|
|
pr_err("Failed: extra option specified '%s'", opt);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-05 14:44:41 +00:00
|
|
|
static int setup_compute(const struct option *opt, const char *str,
|
|
|
|
int unset __maybe_unused)
|
|
|
|
{
|
|
|
|
int *cp = (int *) opt->value;
|
2012-10-05 14:44:43 +00:00
|
|
|
char *cstr = (char *) str;
|
|
|
|
char buf[50];
|
2012-10-05 14:44:41 +00:00
|
|
|
unsigned i;
|
2012-10-05 14:44:43 +00:00
|
|
|
char *option;
|
2012-10-05 14:44:41 +00:00
|
|
|
|
|
|
|
if (!str) {
|
|
|
|
*cp = COMPUTE_DELTA;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-05 14:44:43 +00:00
|
|
|
option = strchr(str, ':');
|
|
|
|
if (option) {
|
|
|
|
unsigned len = option++ - str;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The str data are not writeable, so we need
|
|
|
|
* to use another buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* No option value is longer. */
|
|
|
|
if (len >= sizeof(buf))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
strncpy(buf, str, len);
|
|
|
|
buf[len] = 0x0;
|
|
|
|
cstr = buf;
|
|
|
|
}
|
|
|
|
|
2012-10-05 14:44:41 +00:00
|
|
|
for (i = 0; i < COMPUTE_MAX; i++)
|
2012-10-05 14:44:43 +00:00
|
|
|
if (!strcmp(cstr, compute_names[i])) {
|
2012-10-05 14:44:41 +00:00
|
|
|
*cp = i;
|
2012-10-05 14:44:43 +00:00
|
|
|
return setup_compute_opt(option);
|
2012-10-05 14:44:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pr_err("Failed: '%s' is not computation method "
|
2012-10-05 14:44:43 +00:00
|
|
|
"(use 'delta','ratio' or 'wdiff')\n", str);
|
2012-10-05 14:44:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-10-21 21:31:51 +00:00
|
|
|
static double period_percent(struct hist_entry *he, u64 period)
|
2012-10-05 14:44:42 +00:00
|
|
|
{
|
2014-02-07 03:06:07 +00:00
|
|
|
u64 total = hists__total_period(he->hists);
|
|
|
|
|
2012-10-05 14:44:42 +00:00
|
|
|
return (period * 100.0) / total;
|
|
|
|
}
|
|
|
|
|
2012-10-21 21:31:51 +00:00
|
|
|
static double compute_delta(struct hist_entry *he, struct hist_entry *pair)
|
2012-10-05 14:44:42 +00:00
|
|
|
{
|
2012-10-21 21:31:51 +00:00
|
|
|
double old_percent = period_percent(he, he->stat.period);
|
|
|
|
double new_percent = period_percent(pair, pair->stat.period);
|
2012-10-05 14:44:42 +00:00
|
|
|
|
2012-12-01 20:15:40 +00:00
|
|
|
pair->diff.period_ratio_delta = new_percent - old_percent;
|
|
|
|
pair->diff.computed = true;
|
|
|
|
return pair->diff.period_ratio_delta;
|
2012-10-05 14:44:42 +00:00
|
|
|
}
|
|
|
|
|
2012-10-21 21:31:51 +00:00
|
|
|
static double compute_ratio(struct hist_entry *he, struct hist_entry *pair)
|
2012-10-05 14:44:42 +00:00
|
|
|
{
|
2012-12-01 20:15:40 +00:00
|
|
|
double old_period = he->stat.period ?: 1;
|
|
|
|
double new_period = pair->stat.period;
|
2012-10-05 14:44:42 +00:00
|
|
|
|
2012-12-01 20:15:40 +00:00
|
|
|
pair->diff.computed = true;
|
|
|
|
pair->diff.period_ratio = new_period / old_period;
|
|
|
|
return pair->diff.period_ratio;
|
2012-10-05 14:44:42 +00:00
|
|
|
}
|
|
|
|
|
2012-10-21 21:31:51 +00:00
|
|
|
static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
|
2012-10-05 14:44:43 +00:00
|
|
|
{
|
2012-12-01 20:15:40 +00:00
|
|
|
u64 old_period = he->stat.period;
|
|
|
|
u64 new_period = pair->stat.period;
|
2012-10-05 14:44:43 +00:00
|
|
|
|
2012-12-01 20:15:40 +00:00
|
|
|
pair->diff.computed = true;
|
|
|
|
pair->diff.wdiff = new_period * compute_wdiff_w2 -
|
|
|
|
old_period * compute_wdiff_w1;
|
2012-10-05 14:44:43 +00:00
|
|
|
|
2012-12-01 20:15:40 +00:00
|
|
|
return pair->diff.wdiff;
|
2012-10-05 14:44:43 +00:00
|
|
|
}
|
|
|
|
|
2012-11-28 13:52:41 +00:00
|
|
|
static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
char *buf, size_t size)
|
2012-10-05 14:44:45 +00:00
|
|
|
{
|
2014-02-07 03:06:07 +00:00
|
|
|
u64 he_total = he->hists->stats.total_period;
|
|
|
|
u64 pair_total = pair->hists->stats.total_period;
|
|
|
|
|
|
|
|
if (symbol_conf.filter_relative) {
|
|
|
|
he_total = he->hists->stats.total_non_filtered_period;
|
|
|
|
pair_total = pair->hists->stats.total_non_filtered_period;
|
|
|
|
}
|
2012-10-05 14:44:45 +00:00
|
|
|
return scnprintf(buf, size,
|
|
|
|
"(%" PRIu64 " * 100 / %" PRIu64 ") - "
|
|
|
|
"(%" PRIu64 " * 100 / %" PRIu64 ")",
|
2014-02-07 03:06:07 +00:00
|
|
|
pair->stat.period, pair_total,
|
|
|
|
he->stat.period, he_total);
|
2012-10-05 14:44:45 +00:00
|
|
|
}
|
|
|
|
|
2012-11-28 13:52:41 +00:00
|
|
|
static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
char *buf, size_t size)
|
2012-10-05 14:44:45 +00:00
|
|
|
{
|
2012-12-01 20:15:40 +00:00
|
|
|
double old_period = he->stat.period;
|
|
|
|
double new_period = pair->stat.period;
|
2012-10-05 14:44:45 +00:00
|
|
|
|
|
|
|
return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
|
|
|
|
}
|
|
|
|
|
2012-11-28 13:52:41 +00:00
|
|
|
static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
char *buf, size_t size)
|
2012-10-05 14:44:45 +00:00
|
|
|
{
|
2012-12-01 20:15:40 +00:00
|
|
|
u64 old_period = he->stat.period;
|
|
|
|
u64 new_period = pair->stat.period;
|
2012-10-05 14:44:45 +00:00
|
|
|
|
|
|
|
return scnprintf(buf, size,
|
|
|
|
"(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
|
|
|
|
new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
|
|
|
|
}
|
|
|
|
|
2012-10-21 21:31:51 +00:00
|
|
|
static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
char *buf, size_t size)
|
2012-10-05 14:44:45 +00:00
|
|
|
{
|
|
|
|
switch (compute) {
|
|
|
|
case COMPUTE_DELTA:
|
2017-02-10 07:36:11 +00:00
|
|
|
case COMPUTE_DELTA_ABS:
|
2012-11-28 13:52:41 +00:00
|
|
|
return formula_delta(he, pair, buf, size);
|
2012-10-05 14:44:45 +00:00
|
|
|
case COMPUTE_RATIO:
|
2012-11-28 13:52:41 +00:00
|
|
|
return formula_ratio(he, pair, buf, size);
|
2012-10-05 14:44:45 +00:00
|
|
|
case COMPUTE_WEIGHTED_DIFF:
|
2012-11-28 13:52:41 +00:00
|
|
|
return formula_wdiff(he, pair, buf, size);
|
2012-10-05 14:44:45 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:01 +00:00
|
|
|
static void *block_hist_zalloc(size_t size)
|
|
|
|
{
|
|
|
|
struct block_hist *bh;
|
|
|
|
|
|
|
|
bh = zalloc(size + sizeof(*bh));
|
|
|
|
if (!bh)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &bh->he;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_hist_free(void *he)
|
|
|
|
{
|
|
|
|
struct block_hist *bh;
|
|
|
|
|
|
|
|
bh = container_of(he, struct block_hist, he);
|
|
|
|
hists__delete_entries(&bh->block_hists);
|
|
|
|
free(bh);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct hist_entry_ops block_hist_ops = {
|
|
|
|
.new = block_hist_zalloc,
|
|
|
|
.free = block_hist_free,
|
|
|
|
};
|
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
static int diff__process_sample_event(struct perf_tool *tool,
|
2011-11-25 10:19:45 +00:00
|
|
|
union perf_event *event,
|
2011-01-29 15:02:00 +00:00
|
|
|
struct perf_sample *sample,
|
2019-07-21 11:23:51 +00:00
|
|
|
struct evsel *evsel,
|
2011-11-28 09:56:39 +00:00
|
|
|
struct machine *machine)
|
2009-12-14 22:09:31 +00:00
|
|
|
{
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
struct perf_diff *pdiff = container_of(tool, struct perf_diff, tool);
|
2009-12-14 22:09:31 +00:00
|
|
|
struct addr_location al;
|
2014-10-09 16:13:41 +00:00
|
|
|
struct hists *hists = evsel__hists(evsel);
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
struct hist_entry_iter iter = {
|
|
|
|
.evsel = evsel,
|
|
|
|
.sample = sample,
|
|
|
|
.ops = &hist_iter_normal,
|
|
|
|
};
|
perf machine: Protect the machine->threads with a rwlock
In addition to using refcounts for the struct thread lifetime
management, we need to protect access to machine->threads from
concurrent access.
That happens in 'perf top', where a thread processes events, inserting
and deleting entries from that rb_tree while another thread decays
hist_entries, that end up dropping references and ultimately deleting
threads from the rb_tree and releasing its resources when no further
hist_entry (or other data structures, like in 'perf sched') references
it.
So the rule is the same for refcounts + protected trees in the kernel,
get the tree lock, find object, bump the refcount, drop the tree lock,
return, use object, drop the refcount if no more use of it is needed,
keep it if storing it in some other data structure, drop when releasing
that data structure.
I.e. pair "t = machine__find(new)_thread()" with a "thread__put(t)", and
"perf_event__preprocess_sample(&al)" with "addr_location__put(&al)".
The addr_location__put() one is because as we return references to
several data structures, we may end up adding more reference counting
for the other data structures and then we'll drop it at
addr_location__put() time.
Acked-by: David Ahern <dsahern@gmail.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-bs9rt4n0jw3hi9f3zxyy3xln@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-06 23:43:22 +00:00
|
|
|
int ret = -1;
|
2009-12-14 22:09:31 +00:00
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
if (perf_time__ranges_skip_sample(pdiff->ptime_range, pdiff->range_num,
|
|
|
|
sample->time)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-22 21:39:09 +00:00
|
|
|
if (machine__resolve(machine, &al, sample) < 0) {
|
2009-12-14 22:09:31 +00:00
|
|
|
pr_warning("problem processing %d event, skipping it.\n",
|
|
|
|
event->header.type);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-03-05 13:05:42 +00:00
|
|
|
if (cpu_list && !test_bit(sample->cpu, cpu_bitmap)) {
|
|
|
|
ret = 0;
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
switch (compute) {
|
|
|
|
case COMPUTE_CYCLES:
|
2019-06-28 09:23:01 +00:00
|
|
|
if (!hists__add_entry_ops(hists, &block_hist_ops, &al, NULL,
|
2023-03-15 14:51:05 +00:00
|
|
|
NULL, NULL, NULL, sample, true)) {
|
2019-06-28 09:23:01 +00:00
|
|
|
pr_warning("problem incrementing symbol period, "
|
|
|
|
"skipping event\n");
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
|
2019-11-07 07:47:15 +00:00
|
|
|
hist__account_cycles(sample->branch_stack, &al, sample, false,
|
|
|
|
NULL);
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case COMPUTE_STREAM:
|
|
|
|
if (hist_entry_iter__add(&iter, &al, PERF_MAX_STACK_DEPTH,
|
|
|
|
NULL)) {
|
|
|
|
pr_debug("problem adding hist entry, skipping event\n");
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2023-03-15 14:51:05 +00:00
|
|
|
if (!hists__add_entry(hists, &al, NULL, NULL, NULL, NULL, sample,
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
true)) {
|
|
|
|
pr_warning("problem incrementing symbol period, "
|
|
|
|
"skipping event\n");
|
|
|
|
goto out_put;
|
|
|
|
}
|
2009-12-14 22:09:31 +00:00
|
|
|
}
|
|
|
|
|
2014-04-22 02:44:21 +00:00
|
|
|
/*
|
|
|
|
* The total_period is updated here before going to the output
|
|
|
|
* tree since normally only the baseline hists will call
|
|
|
|
* hists__output_resort() and precompute needs the total
|
|
|
|
* period in order to sort entries by percentage delta.
|
|
|
|
*/
|
2014-10-09 16:13:41 +00:00
|
|
|
hists->stats.total_period += sample->period;
|
2014-04-22 02:44:21 +00:00
|
|
|
if (!al.filtered)
|
2014-10-09 16:13:41 +00:00
|
|
|
hists->stats.total_non_filtered_period += sample->period;
|
perf machine: Protect the machine->threads with a rwlock
In addition to using refcounts for the struct thread lifetime
management, we need to protect access to machine->threads from
concurrent access.
That happens in 'perf top', where a thread processes events, inserting
and deleting entries from that rb_tree while another thread decays
hist_entries, that end up dropping references and ultimately deleting
threads from the rb_tree and releasing its resources when no further
hist_entry (or other data structures, like in 'perf sched') references
it.
So the rule is the same for refcounts + protected trees in the kernel,
get the tree lock, find object, bump the refcount, drop the tree lock,
return, use object, drop the refcount if no more use of it is needed,
keep it if storing it in some other data structure, drop when releasing
that data structure.
I.e. pair "t = machine__find(new)_thread()" with a "thread__put(t)", and
"perf_event__preprocess_sample(&al)" with "addr_location__put(&al)".
The addr_location__put() one is because as we return references to
several data structures, we may end up adding more reference counting
for the other data structures and then we'll drop it at
addr_location__put() time.
Acked-by: David Ahern <dsahern@gmail.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: Don Zickus <dzickus@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-bs9rt4n0jw3hi9f3zxyy3xln@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2015-04-06 23:43:22 +00:00
|
|
|
ret = 0;
|
|
|
|
out_put:
|
|
|
|
addr_location__put(&al);
|
|
|
|
return ret;
|
2009-12-14 22:09:31 +00:00
|
|
|
}
|
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
static struct perf_diff pdiff = {
|
|
|
|
.tool = {
|
|
|
|
.sample = diff__process_sample_event,
|
|
|
|
.mmap = perf_event__process_mmap,
|
|
|
|
.mmap2 = perf_event__process_mmap2,
|
|
|
|
.comm = perf_event__process_comm,
|
|
|
|
.exit = perf_event__process_exit,
|
|
|
|
.fork = perf_event__process_fork,
|
|
|
|
.lost = perf_event__process_lost,
|
|
|
|
.namespaces = perf_event__process_namespaces,
|
2020-03-25 12:45:30 +00:00
|
|
|
.cgroup = perf_event__process_cgroup,
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
.ordered_events = true,
|
|
|
|
.ordering_requires_timestamps = true,
|
|
|
|
},
|
2009-12-14 22:09:31 +00:00
|
|
|
};
|
|
|
|
|
2019-07-21 11:23:51 +00:00
|
|
|
static struct evsel *evsel_match(struct evsel *evsel,
|
2019-07-21 11:23:52 +00:00
|
|
|
struct evlist *evlist)
|
2012-09-06 15:46:55 +00:00
|
|
|
{
|
2019-07-21 11:23:51 +00:00
|
|
|
struct evsel *e;
|
2012-09-06 15:46:55 +00:00
|
|
|
|
2016-06-23 14:26:15 +00:00
|
|
|
evlist__for_each_entry(evlist, e) {
|
2020-04-30 13:51:16 +00:00
|
|
|
if (evsel__match2(evsel, e))
|
2012-09-06 15:46:55 +00:00
|
|
|
return e;
|
2014-01-10 13:37:27 +00:00
|
|
|
}
|
2012-09-06 15:46:55 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-11-30 18:18:48 +00:00
|
|
|
static void evlist__collapse_resort(struct evlist *evlist)
|
2012-10-04 12:49:36 +00:00
|
|
|
{
|
2019-07-21 11:23:51 +00:00
|
|
|
struct evsel *evsel;
|
2012-10-04 12:49:36 +00:00
|
|
|
|
2016-06-23 14:26:15 +00:00
|
|
|
evlist__for_each_entry(evlist, evsel) {
|
2014-10-09 16:13:41 +00:00
|
|
|
struct hists *hists = evsel__hists(evsel);
|
2012-10-04 12:49:36 +00:00
|
|
|
|
2013-10-11 05:15:38 +00:00
|
|
|
hists__collapse_resort(hists, NULL);
|
2012-10-04 12:49:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-08 00:45:45 +00:00
|
|
|
static struct data__file *fmt_to_data_file(struct perf_hpp_fmt *fmt)
|
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt = container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
void *ptr = dfmt - dfmt->idx;
|
|
|
|
struct data__file *d = container_of(ptr, struct data__file, fmt);
|
|
|
|
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:10:20 +00:00
|
|
|
static struct hist_entry*
|
|
|
|
get_pair_data(struct hist_entry *he, struct data__file *d)
|
|
|
|
{
|
|
|
|
if (hist_entry__has_pairs(he)) {
|
|
|
|
struct hist_entry *pair;
|
|
|
|
|
|
|
|
list_for_each_entry(pair, &he->pairs.head, pairs.node)
|
|
|
|
if (pair->hists == d->hists)
|
|
|
|
return pair;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hist_entry*
|
|
|
|
get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt)
|
|
|
|
{
|
2015-01-08 00:45:45 +00:00
|
|
|
struct data__file *d = fmt_to_data_file(&dfmt->fmt);
|
2012-11-25 22:10:20 +00:00
|
|
|
|
|
|
|
return get_pair_data(he, d);
|
|
|
|
}
|
|
|
|
|
2012-10-05 14:44:40 +00:00
|
|
|
static void hists__baseline_only(struct hists *hists)
|
|
|
|
{
|
2018-12-06 19:18:18 +00:00
|
|
|
struct rb_root_cached *root;
|
2012-12-10 08:29:55 +00:00
|
|
|
struct rb_node *next;
|
|
|
|
|
2016-05-03 11:54:42 +00:00
|
|
|
if (hists__has(hists, need_collapse))
|
2012-12-10 08:29:55 +00:00
|
|
|
root = &hists->entries_collapsed;
|
|
|
|
else
|
|
|
|
root = hists->entries_in;
|
2012-10-05 14:44:40 +00:00
|
|
|
|
2018-12-06 19:18:18 +00:00
|
|
|
next = rb_first_cached(root);
|
2012-10-05 14:44:40 +00:00
|
|
|
while (next != NULL) {
|
2012-12-10 08:29:55 +00:00
|
|
|
struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
|
2012-10-05 14:44:40 +00:00
|
|
|
|
2012-12-10 08:29:55 +00:00
|
|
|
next = rb_next(&he->rb_node_in);
|
2012-10-25 16:42:45 +00:00
|
|
|
if (!hist_entry__next_pair(he)) {
|
2018-12-06 19:18:18 +00:00
|
|
|
rb_erase_cached(&he->rb_node_in, root);
|
2014-12-19 15:31:40 +00:00
|
|
|
hist_entry__delete(he);
|
2012-10-05 14:44:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:01 +00:00
|
|
|
static int64_t block_cycles_diff_cmp(struct hist_entry *left,
|
|
|
|
struct hist_entry *right)
|
|
|
|
{
|
|
|
|
bool pairs_left = hist_entry__has_pairs(left);
|
|
|
|
bool pairs_right = hist_entry__has_pairs(right);
|
|
|
|
s64 l, r;
|
|
|
|
|
|
|
|
if (!pairs_left && !pairs_right)
|
|
|
|
return 0;
|
|
|
|
|
2019-11-27 12:58:22 +00:00
|
|
|
l = llabs(left->diff.cycles);
|
|
|
|
r = llabs(right->diff.cycles);
|
2019-06-28 09:23:01 +00:00
|
|
|
return r - l;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t block_sort(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
return block_cycles_diff_cmp(right, left);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_block_hist(struct block_hist *bh)
|
|
|
|
{
|
|
|
|
__hists__init(&bh->block_hists, &bh->block_list);
|
|
|
|
perf_hpp_list__init(&bh->block_list);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&bh->block_fmt.list);
|
|
|
|
INIT_LIST_HEAD(&bh->block_fmt.sort_list);
|
2019-11-07 07:47:14 +00:00
|
|
|
bh->block_fmt.cmp = block_info__cmp;
|
2019-06-28 09:23:01 +00:00
|
|
|
bh->block_fmt.sort = block_sort;
|
|
|
|
perf_hpp_list__register_sort_field(&bh->block_list,
|
|
|
|
&bh->block_fmt);
|
|
|
|
bh->valid = true;
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:02 +00:00
|
|
|
static struct hist_entry *get_block_pair(struct hist_entry *he,
|
|
|
|
struct hists *hists_pair)
|
|
|
|
{
|
|
|
|
struct rb_root_cached *root = hists_pair->entries_in;
|
|
|
|
struct rb_node *next = rb_first_cached(root);
|
2020-02-02 14:16:53 +00:00
|
|
|
int64_t cmp;
|
2019-06-28 09:23:02 +00:00
|
|
|
|
|
|
|
while (next != NULL) {
|
|
|
|
struct hist_entry *he_pair = rb_entry(next, struct hist_entry,
|
|
|
|
rb_node_in);
|
|
|
|
|
|
|
|
next = rb_next(&he_pair->rb_node_in);
|
|
|
|
|
2020-02-02 14:16:53 +00:00
|
|
|
cmp = __block_info__cmp(he_pair, he);
|
2019-06-28 09:23:02 +00:00
|
|
|
if (!cmp)
|
|
|
|
return he_pair;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-09-25 01:14:46 +00:00
|
|
|
static void init_spark_values(unsigned long *svals, int num)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < num; i++)
|
|
|
|
svals[i] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void update_spark_value(unsigned long *svals, int num,
|
|
|
|
struct stats *stats, u64 val)
|
|
|
|
{
|
|
|
|
int n = stats->n;
|
|
|
|
|
|
|
|
if (n < num)
|
|
|
|
svals[n] = val;
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:02 +00:00
|
|
|
static void compute_cycles_diff(struct hist_entry *he,
|
|
|
|
struct hist_entry *pair)
|
|
|
|
{
|
|
|
|
pair->diff.computed = true;
|
|
|
|
if (pair->block_info->num && he->block_info->num) {
|
|
|
|
pair->diff.cycles =
|
|
|
|
pair->block_info->cycles_aggr / pair->block_info->num_aggr -
|
|
|
|
he->block_info->cycles_aggr / he->block_info->num_aggr;
|
2019-09-25 01:14:46 +00:00
|
|
|
|
|
|
|
if (!cycles_hist)
|
|
|
|
return;
|
|
|
|
|
|
|
|
init_stats(&pair->diff.stats);
|
|
|
|
init_spark_values(pair->diff.svals, NUM_SPARKS);
|
|
|
|
|
|
|
|
for (int i = 0; i < pair->block_info->num; i++) {
|
|
|
|
u64 val;
|
|
|
|
|
|
|
|
if (i >= he->block_info->num || i >= NUM_SPARKS)
|
|
|
|
break;
|
|
|
|
|
2019-11-27 12:58:22 +00:00
|
|
|
val = llabs(pair->block_info->cycles_spark[i] -
|
2019-09-25 01:14:46 +00:00
|
|
|
he->block_info->cycles_spark[i]);
|
|
|
|
|
|
|
|
update_spark_value(pair->diff.svals, NUM_SPARKS,
|
|
|
|
&pair->diff.stats, val);
|
|
|
|
update_stats(&pair->diff.stats, val);
|
|
|
|
}
|
2019-06-28 09:23:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_hists_match(struct hists *hists_base,
|
|
|
|
struct hists *hists_pair)
|
|
|
|
{
|
|
|
|
struct rb_root_cached *root = hists_base->entries_in;
|
|
|
|
struct rb_node *next = rb_first_cached(root);
|
|
|
|
|
|
|
|
while (next != NULL) {
|
|
|
|
struct hist_entry *he = rb_entry(next, struct hist_entry,
|
|
|
|
rb_node_in);
|
|
|
|
struct hist_entry *pair = get_block_pair(he, hists_pair);
|
|
|
|
|
|
|
|
next = rb_next(&he->rb_node_in);
|
|
|
|
|
|
|
|
if (pair) {
|
|
|
|
hist_entry__add_pair(pair, he);
|
|
|
|
compute_cycles_diff(he, pair);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-05 14:44:42 +00:00
|
|
|
static void hists__precompute(struct hists *hists)
|
|
|
|
{
|
2018-12-06 19:18:18 +00:00
|
|
|
struct rb_root_cached *root;
|
2012-12-13 13:08:59 +00:00
|
|
|
struct rb_node *next;
|
|
|
|
|
2016-05-03 11:54:42 +00:00
|
|
|
if (hists__has(hists, need_collapse))
|
2012-12-13 13:08:59 +00:00
|
|
|
root = &hists->entries_collapsed;
|
|
|
|
else
|
|
|
|
root = hists->entries_in;
|
2012-10-05 14:44:42 +00:00
|
|
|
|
2018-12-06 19:18:18 +00:00
|
|
|
next = rb_first_cached(root);
|
2012-10-05 14:44:42 +00:00
|
|
|
while (next != NULL) {
|
2019-06-28 09:23:02 +00:00
|
|
|
struct block_hist *bh, *pair_bh;
|
2012-11-25 22:10:20 +00:00
|
|
|
struct hist_entry *he, *pair;
|
2015-01-08 00:45:47 +00:00
|
|
|
struct data__file *d;
|
|
|
|
int i;
|
2012-10-05 14:44:42 +00:00
|
|
|
|
2012-11-25 22:10:20 +00:00
|
|
|
he = rb_entry(next, struct hist_entry, rb_node_in);
|
2012-12-13 13:08:59 +00:00
|
|
|
next = rb_next(&he->rb_node_in);
|
2012-11-25 22:10:20 +00:00
|
|
|
|
2019-11-07 07:47:14 +00:00
|
|
|
if (compute == COMPUTE_CYCLES) {
|
|
|
|
bh = container_of(he, struct block_hist, he);
|
|
|
|
init_block_hist(bh);
|
|
|
|
block_info__process_sym(he, bh, NULL, 0);
|
|
|
|
}
|
2019-06-28 09:23:01 +00:00
|
|
|
|
2015-01-08 00:45:47 +00:00
|
|
|
data__for_each_file_new(i, d) {
|
|
|
|
pair = get_pair_data(he, d);
|
|
|
|
if (!pair)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (compute) {
|
|
|
|
case COMPUTE_DELTA:
|
2017-02-10 07:36:11 +00:00
|
|
|
case COMPUTE_DELTA_ABS:
|
2015-01-08 00:45:47 +00:00
|
|
|
compute_delta(he, pair);
|
|
|
|
break;
|
|
|
|
case COMPUTE_RATIO:
|
|
|
|
compute_ratio(he, pair);
|
|
|
|
break;
|
|
|
|
case COMPUTE_WEIGHTED_DIFF:
|
|
|
|
compute_wdiff(he, pair);
|
|
|
|
break;
|
2019-06-28 09:23:01 +00:00
|
|
|
case COMPUTE_CYCLES:
|
2019-06-28 09:23:02 +00:00
|
|
|
pair_bh = container_of(pair, struct block_hist,
|
|
|
|
he);
|
2019-11-07 07:47:14 +00:00
|
|
|
init_block_hist(pair_bh);
|
|
|
|
block_info__process_sym(pair, pair_bh, NULL, 0);
|
|
|
|
|
|
|
|
bh = container_of(he, struct block_hist, he);
|
2019-06-28 09:23:02 +00:00
|
|
|
|
|
|
|
if (bh->valid && pair_bh->valid) {
|
|
|
|
block_hists_match(&bh->block_hists,
|
|
|
|
&pair_bh->block_hists);
|
2019-11-07 07:47:13 +00:00
|
|
|
hists__output_resort(&pair_bh->block_hists,
|
|
|
|
NULL);
|
2019-06-28 09:23:02 +00:00
|
|
|
}
|
2019-06-28 09:23:01 +00:00
|
|
|
break;
|
2015-01-08 00:45:47 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
2012-10-05 14:44:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t cmp_doubles(double l, double r)
|
|
|
|
{
|
|
|
|
if (l > r)
|
|
|
|
return -1;
|
|
|
|
else if (l < r)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
2012-11-25 22:10:20 +00:00
|
|
|
__hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
|
2012-10-05 14:44:42 +00:00
|
|
|
int c)
|
|
|
|
{
|
|
|
|
switch (c) {
|
|
|
|
case COMPUTE_DELTA:
|
|
|
|
{
|
|
|
|
double l = left->diff.period_ratio_delta;
|
|
|
|
double r = right->diff.period_ratio_delta;
|
|
|
|
|
|
|
|
return cmp_doubles(l, r);
|
|
|
|
}
|
2017-02-10 07:36:11 +00:00
|
|
|
case COMPUTE_DELTA_ABS:
|
|
|
|
{
|
|
|
|
double l = fabs(left->diff.period_ratio_delta);
|
|
|
|
double r = fabs(right->diff.period_ratio_delta);
|
|
|
|
|
|
|
|
return cmp_doubles(l, r);
|
|
|
|
}
|
2012-10-05 14:44:42 +00:00
|
|
|
case COMPUTE_RATIO:
|
|
|
|
{
|
|
|
|
double l = left->diff.period_ratio;
|
|
|
|
double r = right->diff.period_ratio;
|
|
|
|
|
|
|
|
return cmp_doubles(l, r);
|
|
|
|
}
|
2012-10-05 14:44:43 +00:00
|
|
|
case COMPUTE_WEIGHTED_DIFF:
|
|
|
|
{
|
|
|
|
s64 l = left->diff.wdiff;
|
|
|
|
s64 r = right->diff.wdiff;
|
|
|
|
|
|
|
|
return r - l;
|
|
|
|
}
|
2012-10-05 14:44:42 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:10:20 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
|
2015-01-08 00:45:47 +00:00
|
|
|
int c, int sort_idx)
|
2012-11-25 22:10:20 +00:00
|
|
|
{
|
|
|
|
bool pairs_left = hist_entry__has_pairs(left);
|
|
|
|
bool pairs_right = hist_entry__has_pairs(right);
|
|
|
|
struct hist_entry *p_right, *p_left;
|
|
|
|
|
|
|
|
if (!pairs_left && !pairs_right)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!pairs_left || !pairs_right)
|
|
|
|
return pairs_left ? -1 : 1;
|
|
|
|
|
2015-01-08 00:45:47 +00:00
|
|
|
p_left = get_pair_data(left, &data__files[sort_idx]);
|
|
|
|
p_right = get_pair_data(right, &data__files[sort_idx]);
|
2012-11-25 22:10:20 +00:00
|
|
|
|
|
|
|
if (!p_left && !p_right)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!p_left || !p_right)
|
|
|
|
return p_left ? -1 : 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have 2 entries of same kind, let's
|
|
|
|
* make the data comparison.
|
|
|
|
*/
|
|
|
|
return __hist_entry__cmp_compute(p_left, p_right, c);
|
|
|
|
}
|
|
|
|
|
2015-01-08 00:45:48 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_compute_idx(struct hist_entry *left, struct hist_entry *right,
|
|
|
|
int c, int sort_idx)
|
|
|
|
{
|
|
|
|
struct hist_entry *p_right, *p_left;
|
|
|
|
|
|
|
|
p_left = get_pair_data(left, &data__files[sort_idx]);
|
|
|
|
p_right = get_pair_data(right, &data__files[sort_idx]);
|
|
|
|
|
|
|
|
if (!p_left && !p_right)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!p_left || !p_right)
|
|
|
|
return p_left ? -1 : 1;
|
|
|
|
|
2017-02-10 07:36:11 +00:00
|
|
|
if (c != COMPUTE_DELTA && c != COMPUTE_DELTA_ABS) {
|
2015-01-08 00:45:48 +00:00
|
|
|
/*
|
|
|
|
* The delta can be computed without the baseline, but
|
|
|
|
* others are not. Put those entries which have no
|
|
|
|
* values below.
|
|
|
|
*/
|
|
|
|
if (left->dummy && right->dummy)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (left->dummy || right->dummy)
|
|
|
|
return left->dummy ? 1 : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return __hist_entry__cmp_compute(p_left, p_right, c);
|
|
|
|
}
|
|
|
|
|
2014-12-27 05:06:29 +00:00
|
|
|
static int64_t
|
2015-01-08 00:45:46 +00:00
|
|
|
hist_entry__cmp_nop(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left __maybe_unused,
|
2014-12-27 05:06:29 +00:00
|
|
|
struct hist_entry *right __maybe_unused)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
2015-01-08 00:45:46 +00:00
|
|
|
hist_entry__cmp_baseline(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
2014-12-27 05:06:29 +00:00
|
|
|
{
|
|
|
|
if (left->stat.period == right->stat.period)
|
|
|
|
return 0;
|
|
|
|
return left->stat.period > right->stat.period ? 1 : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
2015-01-08 00:45:47 +00:00
|
|
|
hist_entry__cmp_delta(struct perf_hpp_fmt *fmt,
|
2015-01-08 00:45:46 +00:00
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
2014-12-27 05:06:29 +00:00
|
|
|
{
|
2015-01-08 00:45:47 +00:00
|
|
|
struct data__file *d = fmt_to_data_file(fmt);
|
|
|
|
|
|
|
|
return hist_entry__cmp_compute(right, left, COMPUTE_DELTA, d->idx);
|
2014-12-27 05:06:29 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 07:36:11 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_delta_abs(struct perf_hpp_fmt *fmt,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
struct data__file *d = fmt_to_data_file(fmt);
|
|
|
|
|
|
|
|
return hist_entry__cmp_compute(right, left, COMPUTE_DELTA_ABS, d->idx);
|
|
|
|
}
|
|
|
|
|
2014-12-27 05:06:29 +00:00
|
|
|
static int64_t
|
2015-01-08 00:45:47 +00:00
|
|
|
hist_entry__cmp_ratio(struct perf_hpp_fmt *fmt,
|
2015-01-08 00:45:46 +00:00
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
2014-12-27 05:06:29 +00:00
|
|
|
{
|
2015-01-08 00:45:47 +00:00
|
|
|
struct data__file *d = fmt_to_data_file(fmt);
|
|
|
|
|
|
|
|
return hist_entry__cmp_compute(right, left, COMPUTE_RATIO, d->idx);
|
2014-12-27 05:06:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
2015-01-08 00:45:47 +00:00
|
|
|
hist_entry__cmp_wdiff(struct perf_hpp_fmt *fmt,
|
2015-01-08 00:45:46 +00:00
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
2014-12-27 05:06:29 +00:00
|
|
|
{
|
2015-01-08 00:45:47 +00:00
|
|
|
struct data__file *d = fmt_to_data_file(fmt);
|
|
|
|
|
|
|
|
return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF, d->idx);
|
2014-12-27 05:06:29 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 00:45:48 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_delta_idx(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA,
|
|
|
|
sort_compute);
|
|
|
|
}
|
|
|
|
|
2017-02-10 07:36:11 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_delta_abs_idx(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA_ABS,
|
|
|
|
sort_compute);
|
|
|
|
}
|
|
|
|
|
2015-01-08 00:45:48 +00:00
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_ratio_idx(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
return hist_entry__cmp_compute_idx(right, left, COMPUTE_RATIO,
|
|
|
|
sort_compute);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
|
|
|
hist_entry__cmp_wdiff_idx(struct perf_hpp_fmt *fmt __maybe_unused,
|
|
|
|
struct hist_entry *left, struct hist_entry *right)
|
|
|
|
{
|
|
|
|
return hist_entry__cmp_compute_idx(right, left, COMPUTE_WEIGHTED_DIFF,
|
|
|
|
sort_compute);
|
|
|
|
}
|
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
static void hists__process(struct hists *hists)
|
2012-10-05 14:44:40 +00:00
|
|
|
{
|
|
|
|
if (show_baseline_only)
|
2012-12-01 21:00:00 +00:00
|
|
|
hists__baseline_only(hists);
|
2012-10-05 14:44:40 +00:00
|
|
|
|
2015-01-08 00:45:47 +00:00
|
|
|
hists__precompute(hists);
|
2014-12-27 05:06:30 +00:00
|
|
|
hists__output_resort(hists, NULL);
|
2012-10-05 14:44:42 +00:00
|
|
|
|
2019-06-28 09:23:03 +00:00
|
|
|
if (compute == COMPUTE_CYCLES)
|
|
|
|
symbol_conf.report_block = true;
|
|
|
|
|
2017-02-17 08:17:40 +00:00
|
|
|
hists__fprintf(hists, !quiet, 0, 0, 0, stdout,
|
2018-06-20 18:58:20 +00:00
|
|
|
!symbol_conf.use_callchain);
|
2012-10-05 14:44:40 +00:00
|
|
|
}
|
|
|
|
|
2012-12-01 20:56:03 +00:00
|
|
|
static void data__fprintf(void)
|
|
|
|
{
|
|
|
|
struct data__file *d;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
fprintf(stdout, "# Data files:\n");
|
|
|
|
|
|
|
|
data__for_each_file(i, d)
|
|
|
|
fprintf(stdout, "# [%d] %s %s\n",
|
2019-02-21 09:41:30 +00:00
|
|
|
d->idx, d->data.path,
|
2012-12-01 20:56:03 +00:00
|
|
|
!d->idx ? "(Baseline)" : "");
|
|
|
|
|
|
|
|
fprintf(stdout, "#\n");
|
|
|
|
}
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
static void data_process(void)
|
2009-12-14 22:09:31 +00:00
|
|
|
{
|
2019-07-21 11:23:52 +00:00
|
|
|
struct evlist *evlist_base = data__files[0].session->evlist;
|
2019-07-21 11:23:51 +00:00
|
|
|
struct evsel *evsel_base;
|
2012-09-06 15:46:55 +00:00
|
|
|
bool first = true;
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2016-06-23 14:26:15 +00:00
|
|
|
evlist__for_each_entry(evlist_base, evsel_base) {
|
2014-10-09 16:13:41 +00:00
|
|
|
struct hists *hists_base = evsel__hists(evsel_base);
|
2012-12-01 21:00:00 +00:00
|
|
|
struct data__file *d;
|
|
|
|
int i;
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
data__for_each_file_new(i, d) {
|
2019-07-21 11:23:52 +00:00
|
|
|
struct evlist *evlist = d->session->evlist;
|
2019-07-21 11:23:51 +00:00
|
|
|
struct evsel *evsel;
|
2014-10-09 16:13:41 +00:00
|
|
|
struct hists *hists;
|
2012-12-01 21:00:00 +00:00
|
|
|
|
|
|
|
evsel = evsel_match(evsel_base, evlist);
|
|
|
|
if (!evsel)
|
|
|
|
continue;
|
|
|
|
|
2014-10-09 16:13:41 +00:00
|
|
|
hists = evsel__hists(evsel);
|
|
|
|
d->hists = hists;
|
2012-12-01 21:00:00 +00:00
|
|
|
|
2014-10-09 16:13:41 +00:00
|
|
|
hists__match(hists_base, hists);
|
2012-12-01 21:00:00 +00:00
|
|
|
|
|
|
|
if (!show_baseline_only)
|
2014-10-09 16:13:41 +00:00
|
|
|
hists__link(hists_base, hists);
|
2012-12-01 21:00:00 +00:00
|
|
|
}
|
2009-12-14 22:09:31 +00:00
|
|
|
|
2017-02-17 08:17:40 +00:00
|
|
|
if (!quiet) {
|
|
|
|
fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
|
2020-04-29 19:07:09 +00:00
|
|
|
evsel__name(evsel_base));
|
2017-02-17 08:17:40 +00:00
|
|
|
}
|
2012-09-06 15:46:55 +00:00
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
first = false;
|
2012-09-06 15:46:55 +00:00
|
|
|
|
2017-02-17 08:17:40 +00:00
|
|
|
if (verbose > 0 || ((data__files_cnt > 2) && !quiet))
|
2012-12-01 20:56:03 +00:00
|
|
|
data__fprintf();
|
|
|
|
|
2015-08-11 10:30:48 +00:00
|
|
|
/* Don't sort callchain for perf diff */
|
2020-04-29 19:12:15 +00:00
|
|
|
evsel__reset_sample_bit(evsel_base, CALLCHAIN);
|
2015-08-11 10:30:48 +00:00
|
|
|
|
2014-10-09 16:13:41 +00:00
|
|
|
hists__process(hists_base);
|
2013-03-24 23:02:01 +00:00
|
|
|
}
|
|
|
|
}
|
2012-09-06 15:46:55 +00:00
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
static int process_base_stream(struct data__file *data_base,
|
|
|
|
struct data__file *data_pair,
|
|
|
|
const char *title __maybe_unused)
|
|
|
|
{
|
|
|
|
struct evlist *evlist_base = data_base->session->evlist;
|
|
|
|
struct evlist *evlist_pair = data_pair->session->evlist;
|
|
|
|
struct evsel *evsel_base, *evsel_pair;
|
|
|
|
struct evsel_streams *es_base, *es_pair;
|
|
|
|
|
|
|
|
evlist__for_each_entry(evlist_base, evsel_base) {
|
|
|
|
evsel_pair = evsel_match(evsel_base, evlist_pair);
|
|
|
|
if (!evsel_pair)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
es_base = evsel_streams__entry(data_base->evlist_streams,
|
2021-07-06 15:16:59 +00:00
|
|
|
evsel_base->core.idx);
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (!es_base)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
es_pair = evsel_streams__entry(data_pair->evlist_streams,
|
2021-07-06 15:16:59 +00:00
|
|
|
evsel_pair->core.idx);
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (!es_pair)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
evsel_streams__match(es_base, es_pair);
|
|
|
|
evsel_streams__report(es_base, es_pair);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stream_process(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Stream comparison only supports two data files.
|
|
|
|
* perf.data.old and perf.data. data__files[0] is perf.data.old,
|
|
|
|
* data__files[1] is perf.data.
|
|
|
|
*/
|
|
|
|
process_base_stream(&data__files[0], &data__files[1],
|
|
|
|
"# Output based on old perf data:\n#\n");
|
|
|
|
}
|
|
|
|
|
2012-12-01 20:57:04 +00:00
|
|
|
static void data__free(struct data__file *d)
|
|
|
|
{
|
|
|
|
int col;
|
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (d->evlist_streams)
|
|
|
|
evlist_streams__delete(d->evlist_streams);
|
|
|
|
|
2012-12-01 20:57:04 +00:00
|
|
|
for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) {
|
|
|
|
struct diff_hpp_fmt *fmt = &d->fmt[col];
|
|
|
|
|
2013-12-27 19:55:14 +00:00
|
|
|
zfree(&fmt->header);
|
2012-12-01 20:57:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
static int abstime_str_dup(char **pstr)
|
|
|
|
{
|
|
|
|
char *str = NULL;
|
|
|
|
|
|
|
|
if (pdiff.time_str && strchr(pdiff.time_str, ':')) {
|
|
|
|
str = strdup(pdiff.time_str);
|
|
|
|
if (!str)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
*pstr = str;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_absolute_time(struct data__file *d, char **pstr)
|
|
|
|
{
|
|
|
|
char *p = *pstr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Absolute timestamp for one file has the format: a.b,c.d
|
|
|
|
* For multiple files, the format is: a.b,c.d:a.b,c.d
|
|
|
|
*/
|
|
|
|
p = strchr(*pstr, ':');
|
|
|
|
if (p) {
|
|
|
|
if (p == *pstr) {
|
|
|
|
pr_err("Invalid time string\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*p = 0;
|
|
|
|
p++;
|
|
|
|
if (*p == 0) {
|
|
|
|
pr_err("Invalid time string\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = perf_time__parse_for_ranges(*pstr, d->session,
|
|
|
|
&pdiff.ptime_range,
|
|
|
|
&pdiff.range_size,
|
|
|
|
&pdiff.range_num);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!p || *p == 0)
|
|
|
|
*pstr = NULL;
|
|
|
|
else
|
|
|
|
*pstr = p;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_percent_time(struct data__file *d)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = perf_time__parse_for_ranges(pdiff.time_str, d->session,
|
|
|
|
&pdiff.ptime_range,
|
|
|
|
&pdiff.range_size,
|
|
|
|
&pdiff.range_num);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_time_str(struct data__file *d, char *abstime_ostr,
|
|
|
|
char **pabstime_tmp)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (abstime_ostr)
|
|
|
|
ret = parse_absolute_time(d, pabstime_tmp);
|
|
|
|
else if (pdiff.time_str)
|
|
|
|
ret = parse_percent_time(d);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:00 +00:00
|
|
|
static int check_file_brstack(void)
|
|
|
|
{
|
|
|
|
struct data__file *d;
|
|
|
|
bool has_br_stack;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
data__for_each_file(i, d) {
|
2021-07-19 22:31:49 +00:00
|
|
|
d->session = perf_session__new(&d->data, &pdiff.tool);
|
2019-08-22 07:20:49 +00:00
|
|
|
if (IS_ERR(d->session)) {
|
2019-06-28 09:23:00 +00:00
|
|
|
pr_err("Failed to open %s\n", d->data.path);
|
2019-08-22 07:20:49 +00:00
|
|
|
return PTR_ERR(d->session);
|
2019-06-28 09:23:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
has_br_stack = perf_header__has_feat(&d->session->header,
|
|
|
|
HEADER_BRANCH_STACK);
|
|
|
|
perf_session__delete(d->session);
|
|
|
|
if (!has_br_stack)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set only all files having branch stacks */
|
|
|
|
pdiff.has_br_stack = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
static int __cmd_diff(void)
|
|
|
|
{
|
|
|
|
struct data__file *d;
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
int ret, i;
|
|
|
|
char *abstime_ostr, *abstime_tmp;
|
|
|
|
|
|
|
|
ret = abstime_str_dup(&abstime_ostr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
abstime_tmp = abstime_ostr;
|
|
|
|
ret = -EINVAL;
|
2013-03-24 23:02:01 +00:00
|
|
|
|
|
|
|
data__for_each_file(i, d) {
|
2021-07-19 22:31:49 +00:00
|
|
|
d->session = perf_session__new(&d->data, &pdiff.tool);
|
2019-08-22 07:20:49 +00:00
|
|
|
if (IS_ERR(d->session)) {
|
|
|
|
ret = PTR_ERR(d->session);
|
2019-02-21 09:41:30 +00:00
|
|
|
pr_err("Failed to open %s\n", d->data.path);
|
2013-03-24 23:02:01 +00:00
|
|
|
goto out_delete;
|
|
|
|
}
|
2012-09-06 15:46:55 +00:00
|
|
|
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
if (pdiff.time_str) {
|
|
|
|
ret = parse_time_str(d, abstime_ostr, &abstime_tmp);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_delete;
|
|
|
|
}
|
|
|
|
|
2019-03-05 13:05:42 +00:00
|
|
|
if (cpu_list) {
|
|
|
|
ret = perf_session__cpu_bitmap(d->session, cpu_list,
|
|
|
|
cpu_bitmap);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_delete;
|
|
|
|
}
|
|
|
|
|
2015-03-03 14:58:45 +00:00
|
|
|
ret = perf_session__process_events(d->session);
|
2013-03-24 23:02:01 +00:00
|
|
|
if (ret) {
|
2019-02-21 09:41:30 +00:00
|
|
|
pr_err("Failed to process %s\n", d->data.path);
|
2013-03-24 23:02:01 +00:00
|
|
|
goto out_delete;
|
|
|
|
}
|
2012-09-06 15:46:55 +00:00
|
|
|
|
2020-11-30 18:18:48 +00:00
|
|
|
evlist__collapse_resort(d->session->evlist);
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
|
|
|
|
if (pdiff.ptime_range)
|
|
|
|
zfree(&pdiff.ptime_range);
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
|
|
|
|
if (compute == COMPUTE_STREAM) {
|
|
|
|
d->evlist_streams = evlist__create_streams(
|
|
|
|
d->session->evlist, 5);
|
2020-11-24 10:36:52 +00:00
|
|
|
if (!d->evlist_streams) {
|
|
|
|
ret = -ENOMEM;
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
goto out_delete;
|
2020-11-24 10:36:52 +00:00
|
|
|
}
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
}
|
2013-03-24 23:02:01 +00:00
|
|
|
}
|
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (compute == COMPUTE_STREAM)
|
|
|
|
stream_process();
|
|
|
|
else
|
|
|
|
data_process();
|
2012-09-06 15:46:55 +00:00
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
out_delete:
|
|
|
|
data__for_each_file(i, d) {
|
2021-03-02 02:35:33 +00:00
|
|
|
if (!IS_ERR(d->session))
|
|
|
|
perf_session__delete(d->session);
|
2012-12-01 20:57:04 +00:00
|
|
|
data__free(d);
|
2012-09-06 15:46:55 +00:00
|
|
|
}
|
2009-12-29 00:48:36 +00:00
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
free(data__files);
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
|
|
|
|
if (pdiff.ptime_range)
|
|
|
|
zfree(&pdiff.ptime_range);
|
|
|
|
|
|
|
|
if (abstime_ostr)
|
|
|
|
free(abstime_ostr);
|
|
|
|
|
2009-12-14 22:09:31 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-18 18:35:58 +00:00
|
|
|
static const char * const diff_usage[] = {
|
2009-12-14 22:09:31 +00:00
|
|
|
"perf diff [<options>] [old_file] [new_file]",
|
2009-12-18 18:35:58 +00:00
|
|
|
NULL,
|
2009-12-14 22:09:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct option options[] = {
|
2010-04-13 08:37:33 +00:00
|
|
|
OPT_INCR('v', "verbose", &verbose,
|
2009-12-14 22:09:31 +00:00
|
|
|
"be more verbose (show symbol address, etc)"),
|
2022-10-18 09:41:36 +00:00
|
|
|
OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any warnings or messages"),
|
2012-10-05 14:44:40 +00:00
|
|
|
OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
|
|
|
|
"Show only items with match in baseline"),
|
2012-10-05 14:44:43 +00:00
|
|
|
OPT_CALLBACK('c', "compute", &compute,
|
2019-06-28 09:23:03 +00:00
|
|
|
"delta,delta-abs,ratio,wdiff:w1,w2 (default delta-abs),cycles",
|
2012-10-05 14:44:41 +00:00
|
|
|
"Entries differential computation selection",
|
|
|
|
setup_compute),
|
2012-10-05 14:44:44 +00:00
|
|
|
OPT_BOOLEAN('p', "period", &show_period,
|
|
|
|
"Show period values."),
|
2012-10-05 14:44:45 +00:00
|
|
|
OPT_BOOLEAN('F', "formula", &show_formula,
|
|
|
|
"Show formula."),
|
2019-09-25 01:14:46 +00:00
|
|
|
OPT_BOOLEAN(0, "cycles-hist", &cycles_hist,
|
|
|
|
"Show cycles histogram and standard deviation "
|
|
|
|
"- WARNING: use only with -c cycles."),
|
2009-12-14 22:09:31 +00:00
|
|
|
OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
|
|
|
|
"dump raw trace in ASCII"),
|
|
|
|
OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
|
2015-03-24 15:51:57 +00:00
|
|
|
OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
|
|
|
|
"file", "kallsyms pathname"),
|
2009-12-14 22:09:31 +00:00
|
|
|
OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
|
|
|
|
"load module symbols - WARNING: use only with -k and LIVE kernel"),
|
2009-12-15 22:04:41 +00:00
|
|
|
OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
|
|
|
|
"only consider symbols in these dsos"),
|
|
|
|
OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
|
|
|
|
"only consider symbols in these comms"),
|
|
|
|
OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
|
|
|
|
"only consider these symbols"),
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 15:49:27 +00:00
|
|
|
OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
|
2014-03-04 00:06:42 +00:00
|
|
|
"sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
|
|
|
|
" Please refer the man page for the complete list."),
|
2015-03-20 02:57:52 +00:00
|
|
|
OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 15:49:27 +00:00
|
|
|
"separator for columns, no spaces will be added between "
|
|
|
|
"columns '.' is reserved."),
|
2016-05-19 11:47:37 +00:00
|
|
|
OPT_CALLBACK(0, "symfs", NULL, "directory",
|
|
|
|
"Look for files with symbols relative to this directory",
|
|
|
|
symbol__config_symfs),
|
2012-11-25 22:10:20 +00:00
|
|
|
OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."),
|
2014-02-07 03:06:07 +00:00
|
|
|
OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
|
|
|
|
"How to display percentage of filtered entries", parse_filter_percentage),
|
perf diff: Support --time filter option
To improve 'perf diff', implement a --time filter option to diff the
samples within given time window.
It supports time percent with multiple time ranges. The time string
format is 'a%/n,b%/m,...' or 'a%-b%,c%-%d,...'.
For example:
Select the second 10% time slice to diff:
perf diff --time 10%/2
Select from 0% to 10% time slice to diff:
perf diff --time 0%-10%
Select the first and the second 10% time slices to diff:
perf diff --time 10%/1,10%/2
Select from 0% to 10% and 30% to 40% slices to diff:
perf diff --time 0%-10%,30%-40%
It also supports analysing samples within a given time window
<start>,<stop>.
Times have the format seconds.microseconds.
If 'start' is not given (i.e., time string is ',x.y') then analysis starts at
the beginning of the file.
If the stop time is not given (i.e, time string is 'x.y,') then analysis
goes to end of file.
Time string is 'a1.b1,c1.d1:a2.b2,c2.d2'. Use ':' to separate timestamps for
different perf.data files.
For example, we get the timestamp information from perf script.
perf script -i perf.data.old
mgen 13940 [000] 3946.361400: ...
perf script -i perf.data
mgen 13940 [000] 3971.150589 ...
perf diff --time 3946.361400,:3971.150589,
It analyzes the perf.data.old from the timestamp 3946.361400 to the end of
perf.data.old and analyzes the perf.data from the timestamp 3971.150589 to the
end of perf.data.
v4:
---
Update abstime_str_dup(), let it return error if strdup
is failed, and update __cmd_diff() accordingly.
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Jin Yao <yao.jin@intel.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1551791143-10334-2-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2019-03-05 13:05:41 +00:00
|
|
|
OPT_STRING(0, "time", &pdiff.time_str, "str",
|
|
|
|
"Time span (time percent or absolute timestamp)"),
|
2019-03-05 13:05:42 +00:00
|
|
|
OPT_STRING(0, "cpu", &cpu_list, "cpu", "list of cpus to profile"),
|
2019-03-05 13:05:43 +00:00
|
|
|
OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
|
|
|
|
"only consider symbols in these pids"),
|
|
|
|
OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
|
|
|
|
"only consider symbols in these tids"),
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
OPT_BOOLEAN(0, "stream", &pdiff.stream,
|
|
|
|
"Enable hot streams comparison."),
|
2009-12-14 22:09:31 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
static double baseline_percent(struct hist_entry *he)
|
2012-10-04 12:49:39 +00:00
|
|
|
{
|
2014-02-07 03:06:07 +00:00
|
|
|
u64 total = hists__total_period(he->hists);
|
|
|
|
|
|
|
|
return 100.0 * he->stat.period / total;
|
2013-02-03 19:08:34 +00:00
|
|
|
}
|
2012-10-05 14:44:41 +00:00
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
static int hpp__color_baseline(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
double percent = baseline_percent(he);
|
|
|
|
char pfmt[20] = " ";
|
|
|
|
|
|
|
|
if (!he->dummy) {
|
|
|
|
scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1);
|
|
|
|
return percent_color_snprintf(hpp->buf, hpp->size,
|
|
|
|
pfmt, percent);
|
|
|
|
} else
|
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, pfmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
double percent = baseline_percent(he);
|
|
|
|
const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!he->dummy)
|
|
|
|
ret = scnprintf(buf, size, fmt, percent);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:03 +00:00
|
|
|
static int cycles_printf(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
struct perf_hpp *hpp, int width)
|
|
|
|
{
|
|
|
|
struct block_hist *bh = container_of(he, struct block_hist, he);
|
|
|
|
struct block_hist *bh_pair = container_of(pair, struct block_hist, he);
|
|
|
|
struct hist_entry *block_he;
|
|
|
|
struct block_info *bi;
|
|
|
|
char buf[128];
|
|
|
|
char *start_line, *end_line;
|
|
|
|
|
|
|
|
block_he = hists__get_entry(&bh_pair->block_hists, bh->block_idx);
|
|
|
|
if (!block_he) {
|
|
|
|
hpp->skip = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Avoid printing the warning "addr2line_init failed for ..."
|
|
|
|
*/
|
|
|
|
symbol_conf.disable_add2line_warn = true;
|
|
|
|
|
|
|
|
bi = block_he->block_info;
|
|
|
|
|
|
|
|
start_line = map__srcline(he->ms.map, bi->sym->start + bi->start,
|
|
|
|
he->ms.sym);
|
|
|
|
|
|
|
|
end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
|
|
|
|
he->ms.sym);
|
|
|
|
|
2020-02-23 19:34:49 +00:00
|
|
|
if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) &&
|
|
|
|
(strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) {
|
2019-06-28 09:23:03 +00:00
|
|
|
scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",
|
|
|
|
start_line, end_line, block_he->diff.cycles);
|
|
|
|
} else {
|
|
|
|
scnprintf(buf, sizeof(buf), "[%7lx -> %7lx] %4ld",
|
|
|
|
bi->start, bi->end, block_he->diff.cycles);
|
|
|
|
}
|
|
|
|
|
|
|
|
free_srcline(start_line);
|
|
|
|
free_srcline(end_line);
|
|
|
|
|
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s", width, buf);
|
|
|
|
}
|
|
|
|
|
2013-12-30 07:34:19 +00:00
|
|
|
static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he,
|
|
|
|
int comparison_method)
|
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
struct hist_entry *pair = get_pair_fmt(he, dfmt);
|
|
|
|
double diff;
|
2013-12-30 08:02:35 +00:00
|
|
|
s64 wdiff;
|
2013-12-30 07:34:19 +00:00
|
|
|
char pfmt[20] = " ";
|
|
|
|
|
2019-06-28 09:23:03 +00:00
|
|
|
if (!pair) {
|
|
|
|
if (comparison_method == COMPUTE_CYCLES) {
|
|
|
|
struct block_hist *bh;
|
|
|
|
|
|
|
|
bh = container_of(he, struct block_hist, he);
|
|
|
|
if (bh->block_idx)
|
|
|
|
hpp->skip = true;
|
|
|
|
}
|
|
|
|
|
2014-12-27 05:06:31 +00:00
|
|
|
goto no_print;
|
2019-06-28 09:23:03 +00:00
|
|
|
}
|
2013-12-30 07:34:19 +00:00
|
|
|
|
|
|
|
switch (comparison_method) {
|
|
|
|
case COMPUTE_DELTA:
|
|
|
|
if (pair->diff.computed)
|
|
|
|
diff = pair->diff.period_ratio_delta;
|
|
|
|
else
|
|
|
|
diff = compute_delta(he, pair);
|
|
|
|
|
|
|
|
scnprintf(pfmt, 20, "%%%+d.2f%%%%", dfmt->header_width - 1);
|
|
|
|
return percent_color_snprintf(hpp->buf, hpp->size,
|
|
|
|
pfmt, diff);
|
2013-12-30 07:34:20 +00:00
|
|
|
case COMPUTE_RATIO:
|
|
|
|
if (he->dummy)
|
|
|
|
goto dummy_print;
|
|
|
|
if (pair->diff.computed)
|
|
|
|
diff = pair->diff.period_ratio;
|
|
|
|
else
|
|
|
|
diff = compute_ratio(he, pair);
|
|
|
|
|
|
|
|
scnprintf(pfmt, 20, "%%%d.6f", dfmt->header_width);
|
|
|
|
return value_color_snprintf(hpp->buf, hpp->size,
|
|
|
|
pfmt, diff);
|
2013-12-30 08:02:35 +00:00
|
|
|
case COMPUTE_WEIGHTED_DIFF:
|
|
|
|
if (he->dummy)
|
|
|
|
goto dummy_print;
|
|
|
|
if (pair->diff.computed)
|
|
|
|
wdiff = pair->diff.wdiff;
|
|
|
|
else
|
|
|
|
wdiff = compute_wdiff(he, pair);
|
|
|
|
|
|
|
|
scnprintf(pfmt, 20, "%%14ld", dfmt->header_width);
|
|
|
|
return color_snprintf(hpp->buf, hpp->size,
|
|
|
|
get_percent_color(wdiff),
|
|
|
|
pfmt, wdiff);
|
2019-06-28 09:23:03 +00:00
|
|
|
case COMPUTE_CYCLES:
|
|
|
|
return cycles_printf(he, pair, hpp, dfmt->header_width);
|
2013-12-30 07:34:19 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
dummy_print:
|
2014-12-27 05:06:31 +00:00
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, "N/A");
|
|
|
|
no_print:
|
2013-12-30 07:34:19 +00:00
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, pfmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpp__color_delta(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
return __hpp__color_compare(fmt, hpp, he, COMPUTE_DELTA);
|
|
|
|
}
|
|
|
|
|
2013-12-30 07:34:20 +00:00
|
|
|
static int hpp__color_ratio(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
return __hpp__color_compare(fmt, hpp, he, COMPUTE_RATIO);
|
|
|
|
}
|
|
|
|
|
2013-12-30 08:02:35 +00:00
|
|
|
static int hpp__color_wdiff(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
return __hpp__color_compare(fmt, hpp, he, COMPUTE_WEIGHTED_DIFF);
|
|
|
|
}
|
|
|
|
|
2019-06-28 09:23:03 +00:00
|
|
|
static int hpp__color_cycles(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
return __hpp__color_compare(fmt, hpp, he, COMPUTE_CYCLES);
|
|
|
|
}
|
|
|
|
|
2019-09-25 01:14:46 +00:00
|
|
|
static int all_zero(unsigned long *vals, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (vals[i] != 0)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int print_cycles_spark(char *bf, int size, unsigned long *svals, u64 n)
|
|
|
|
{
|
|
|
|
int printed;
|
|
|
|
|
|
|
|
if (n <= 1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (n > NUM_SPARKS)
|
|
|
|
n = NUM_SPARKS;
|
|
|
|
if (all_zero(svals, n))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
printed = print_spark(bf, size, svals, n);
|
|
|
|
printed += scnprintf(bf + printed, size - printed, " ");
|
|
|
|
return printed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpp__color_cycles_hist(struct perf_hpp_fmt *fmt,
|
|
|
|
struct perf_hpp *hpp, struct hist_entry *he)
|
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
struct hist_entry *pair = get_pair_fmt(he, dfmt);
|
|
|
|
struct block_hist *bh = container_of(he, struct block_hist, he);
|
|
|
|
struct block_hist *bh_pair;
|
|
|
|
struct hist_entry *block_he;
|
|
|
|
char spark[32], buf[128];
|
|
|
|
double r;
|
|
|
|
int ret, pad;
|
|
|
|
|
|
|
|
if (!pair) {
|
|
|
|
if (bh->block_idx)
|
|
|
|
hpp->skip = true;
|
|
|
|
|
|
|
|
goto no_print;
|
|
|
|
}
|
|
|
|
|
|
|
|
bh_pair = container_of(pair, struct block_hist, he);
|
|
|
|
|
|
|
|
block_he = hists__get_entry(&bh_pair->block_hists, bh->block_idx);
|
|
|
|
if (!block_he) {
|
|
|
|
hpp->skip = true;
|
|
|
|
goto no_print;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = print_cycles_spark(spark, sizeof(spark), block_he->diff.svals,
|
|
|
|
block_he->diff.stats.n);
|
|
|
|
|
|
|
|
r = rel_stddev_stats(stddev_stats(&block_he->diff.stats),
|
|
|
|
avg_stats(&block_he->diff.stats));
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
/*
|
|
|
|
* Padding spaces if number of sparks less than NUM_SPARKS
|
|
|
|
* otherwise the output is not aligned.
|
|
|
|
*/
|
|
|
|
pad = NUM_SPARKS - ((ret - 1) / 3);
|
|
|
|
scnprintf(buf, sizeof(buf), "%s%5.1f%% %s", "\u00B1", r, spark);
|
|
|
|
ret = scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, buf);
|
|
|
|
|
|
|
|
if (pad) {
|
|
|
|
ret += scnprintf(hpp->buf + ret, hpp->size - ret,
|
|
|
|
"%-*s", pad, " ");
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
no_print:
|
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, " ");
|
|
|
|
}
|
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
static void
|
|
|
|
hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
switch (idx) {
|
|
|
|
case PERF_HPP_DIFF__PERIOD_BASELINE:
|
|
|
|
scnprintf(buf, size, "%" PRIu64, he->stat.period);
|
2012-10-05 14:44:41 +00:00
|
|
|
break;
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
default:
|
2012-10-05 14:44:43 +00:00
|
|
|
break;
|
2013-02-03 19:08:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
|
|
|
|
int idx, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
double diff;
|
|
|
|
double ratio;
|
|
|
|
s64 wdiff;
|
|
|
|
|
|
|
|
switch (idx) {
|
|
|
|
case PERF_HPP_DIFF__DELTA:
|
2017-02-10 07:36:11 +00:00
|
|
|
case PERF_HPP_DIFF__DELTA_ABS:
|
2013-02-03 19:08:34 +00:00
|
|
|
if (pair->diff.computed)
|
|
|
|
diff = pair->diff.period_ratio_delta;
|
|
|
|
else
|
2012-10-21 21:31:51 +00:00
|
|
|
diff = compute_delta(he, pair);
|
2013-02-03 19:08:34 +00:00
|
|
|
|
2014-12-27 05:06:31 +00:00
|
|
|
scnprintf(buf, size, "%+4.2F%%", diff);
|
2013-02-03 19:08:34 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PERF_HPP_DIFF__RATIO:
|
|
|
|
/* No point for ratio number if we are dummy.. */
|
2014-12-27 05:06:31 +00:00
|
|
|
if (he->dummy) {
|
|
|
|
scnprintf(buf, size, "N/A");
|
2013-02-03 19:08:34 +00:00
|
|
|
break;
|
2014-12-27 05:06:31 +00:00
|
|
|
}
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
if (pair->diff.computed)
|
|
|
|
ratio = pair->diff.period_ratio;
|
|
|
|
else
|
2012-10-21 21:31:51 +00:00
|
|
|
ratio = compute_ratio(he, pair);
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
if (ratio > 0.0)
|
|
|
|
scnprintf(buf, size, "%14.6F", ratio);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PERF_HPP_DIFF__WEIGHTED_DIFF:
|
|
|
|
/* No point for wdiff number if we are dummy.. */
|
2014-12-27 05:06:31 +00:00
|
|
|
if (he->dummy) {
|
|
|
|
scnprintf(buf, size, "N/A");
|
2013-02-03 19:08:34 +00:00
|
|
|
break;
|
2014-12-27 05:06:31 +00:00
|
|
|
}
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
if (pair->diff.computed)
|
|
|
|
wdiff = pair->diff.wdiff;
|
|
|
|
else
|
2012-10-21 21:31:51 +00:00
|
|
|
wdiff = compute_wdiff(he, pair);
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
if (wdiff != 0)
|
|
|
|
scnprintf(buf, size, "%14ld", wdiff);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PERF_HPP_DIFF__FORMULA:
|
2012-10-21 21:31:51 +00:00
|
|
|
formula_fprintf(he, pair, buf, size);
|
2012-10-05 14:44:41 +00:00
|
|
|
break;
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
case PERF_HPP_DIFF__PERIOD:
|
|
|
|
scnprintf(buf, size, "%" PRIu64, pair->stat.period);
|
|
|
|
break;
|
|
|
|
|
2012-10-05 14:44:41 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
2020-04-28 09:18:43 +00:00
|
|
|
}
|
2013-02-03 19:08:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-12-01 21:00:00 +00:00
|
|
|
__hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
|
|
|
|
char *buf, size_t size)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
2012-11-25 22:10:20 +00:00
|
|
|
struct hist_entry *pair = get_pair_fmt(he, dfmt);
|
2012-12-01 21:00:00 +00:00
|
|
|
int idx = dfmt->idx;
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
/* baseline is special */
|
|
|
|
if (idx == PERF_HPP_DIFF__BASELINE)
|
|
|
|
hpp__entry_baseline(he, buf, size);
|
|
|
|
else {
|
|
|
|
if (pair)
|
|
|
|
hpp__entry_pair(he, pair, idx, buf, size);
|
|
|
|
else
|
|
|
|
hpp__entry_unpair(he, idx, buf, size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
|
|
|
|
struct hist_entry *he)
|
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(_fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
char buf[MAX_COL_WIDTH] = " ";
|
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
__hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
|
2013-02-03 19:08:34 +00:00
|
|
|
|
|
|
|
if (symbol_conf.field_sep)
|
|
|
|
return scnprintf(hpp->buf, hpp->size, "%s", buf);
|
|
|
|
else
|
|
|
|
return scnprintf(hpp->buf, hpp->size, "%*s",
|
|
|
|
dfmt->header_width, buf);
|
|
|
|
}
|
|
|
|
|
2014-03-10 07:43:52 +00:00
|
|
|
static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
|
2016-08-07 15:28:27 +00:00
|
|
|
struct hists *hists __maybe_unused,
|
2016-08-07 15:28:30 +00:00
|
|
|
int line __maybe_unused,
|
|
|
|
int *span __maybe_unused)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
|
|
|
|
BUG_ON(!dfmt->header);
|
|
|
|
return scnprintf(hpp->buf, hpp->size, dfmt->header);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpp__width(struct perf_hpp_fmt *fmt,
|
2014-03-10 07:43:52 +00:00
|
|
|
struct perf_hpp *hpp __maybe_unused,
|
2016-06-14 18:19:20 +00:00
|
|
|
struct hists *hists __maybe_unused)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
|
|
|
struct diff_hpp_fmt *dfmt =
|
|
|
|
container_of(fmt, struct diff_hpp_fmt, fmt);
|
|
|
|
|
|
|
|
BUG_ON(dfmt->header_width <= 0);
|
|
|
|
return dfmt->header_width;
|
|
|
|
}
|
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
|
|
|
#define MAX_HEADER_NAME 100
|
|
|
|
char buf_indent[MAX_HEADER_NAME];
|
|
|
|
char buf[MAX_HEADER_NAME];
|
|
|
|
const char *header = NULL;
|
|
|
|
int width = 0;
|
|
|
|
|
|
|
|
BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX);
|
|
|
|
header = columns[dfmt->idx].name;
|
|
|
|
width = columns[dfmt->idx].width;
|
|
|
|
|
|
|
|
/* Only our defined HPP fmts should appear here. */
|
|
|
|
BUG_ON(!header);
|
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
if (data__files_cnt > 2)
|
|
|
|
scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);
|
|
|
|
|
2013-02-03 19:08:34 +00:00
|
|
|
#define NAME (data__files_cnt > 2 ? buf : header)
|
|
|
|
dfmt->header_width = width;
|
|
|
|
width = (int) strlen(NAME);
|
|
|
|
if (dfmt->header_width < width)
|
|
|
|
dfmt->header_width = width;
|
|
|
|
|
|
|
|
scnprintf(buf_indent, MAX_HEADER_NAME, "%*s",
|
|
|
|
dfmt->header_width, NAME);
|
|
|
|
|
|
|
|
dfmt->header = strdup(buf_indent);
|
|
|
|
#undef MAX_HEADER_NAME
|
|
|
|
#undef NAME
|
|
|
|
}
|
|
|
|
|
2012-12-01 20:57:04 +00:00
|
|
|
static void data__hpp_register(struct data__file *d, int idx)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
2012-12-01 20:57:04 +00:00
|
|
|
struct diff_hpp_fmt *dfmt = &d->fmt[idx];
|
|
|
|
struct perf_hpp_fmt *fmt = &dfmt->fmt;
|
|
|
|
|
|
|
|
dfmt->idx = idx;
|
|
|
|
|
|
|
|
fmt->header = hpp__header;
|
|
|
|
fmt->width = hpp__width;
|
|
|
|
fmt->entry = hpp__entry_global;
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->cmp = hist_entry__cmp_nop;
|
|
|
|
fmt->collapse = hist_entry__cmp_nop;
|
2012-12-01 20:57:04 +00:00
|
|
|
|
|
|
|
/* TODO more colors */
|
2013-12-30 07:34:19 +00:00
|
|
|
switch (idx) {
|
|
|
|
case PERF_HPP_DIFF__BASELINE:
|
2012-12-01 20:57:04 +00:00
|
|
|
fmt->color = hpp__color_baseline;
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->sort = hist_entry__cmp_baseline;
|
2013-12-30 07:34:19 +00:00
|
|
|
break;
|
|
|
|
case PERF_HPP_DIFF__DELTA:
|
|
|
|
fmt->color = hpp__color_delta;
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->sort = hist_entry__cmp_delta;
|
2013-12-30 07:34:19 +00:00
|
|
|
break;
|
2013-12-30 07:34:20 +00:00
|
|
|
case PERF_HPP_DIFF__RATIO:
|
|
|
|
fmt->color = hpp__color_ratio;
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->sort = hist_entry__cmp_ratio;
|
2013-12-30 07:34:20 +00:00
|
|
|
break;
|
2013-12-30 08:02:35 +00:00
|
|
|
case PERF_HPP_DIFF__WEIGHTED_DIFF:
|
|
|
|
fmt->color = hpp__color_wdiff;
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->sort = hist_entry__cmp_wdiff;
|
2013-12-30 08:02:35 +00:00
|
|
|
break;
|
2017-02-10 07:36:11 +00:00
|
|
|
case PERF_HPP_DIFF__DELTA_ABS:
|
|
|
|
fmt->color = hpp__color_delta;
|
|
|
|
fmt->sort = hist_entry__cmp_delta_abs;
|
|
|
|
break;
|
2019-06-28 09:23:03 +00:00
|
|
|
case PERF_HPP_DIFF__CYCLES:
|
|
|
|
fmt->color = hpp__color_cycles;
|
|
|
|
fmt->sort = hist_entry__cmp_nop;
|
|
|
|
break;
|
2019-09-25 01:14:46 +00:00
|
|
|
case PERF_HPP_DIFF__CYCLES_HIST:
|
|
|
|
fmt->color = hpp__color_cycles_hist;
|
|
|
|
fmt->sort = hist_entry__cmp_nop;
|
|
|
|
break;
|
2013-12-30 07:34:19 +00:00
|
|
|
default:
|
2014-12-27 05:06:29 +00:00
|
|
|
fmt->sort = hist_entry__cmp_nop;
|
2013-12-30 07:34:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-02-03 19:08:34 +00:00
|
|
|
|
2012-12-01 21:00:00 +00:00
|
|
|
init_header(d, dfmt);
|
2012-12-01 20:57:04 +00:00
|
|
|
perf_hpp__column_register(fmt);
|
2014-12-27 05:06:29 +00:00
|
|
|
perf_hpp__register_sort_field(fmt);
|
2013-02-03 19:08:34 +00:00
|
|
|
}
|
|
|
|
|
2015-01-08 00:45:48 +00:00
|
|
|
static int ui_init(void)
|
2013-02-03 19:08:34 +00:00
|
|
|
{
|
2012-12-01 20:57:04 +00:00
|
|
|
struct data__file *d;
|
2015-01-08 00:45:48 +00:00
|
|
|
struct perf_hpp_fmt *fmt;
|
2012-12-01 20:57:04 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
data__for_each_file(i, d) {
|
|
|
|
|
|
|
|
/*
|
2021-03-23 16:09:15 +00:00
|
|
|
* Baseline or compute related columns:
|
2012-12-01 20:57:04 +00:00
|
|
|
*
|
|
|
|
* PERF_HPP_DIFF__BASELINE
|
|
|
|
* PERF_HPP_DIFF__DELTA
|
|
|
|
* PERF_HPP_DIFF__RATIO
|
|
|
|
* PERF_HPP_DIFF__WEIGHTED_DIFF
|
2019-09-25 01:14:46 +00:00
|
|
|
* PERF_HPP_DIFF__CYCLES
|
2012-12-01 20:57:04 +00:00
|
|
|
*/
|
|
|
|
data__hpp_register(d, i ? compute_2_hpp[compute] :
|
|
|
|
PERF_HPP_DIFF__BASELINE);
|
2012-10-04 12:49:39 +00:00
|
|
|
|
2019-09-25 01:14:46 +00:00
|
|
|
if (cycles_hist && i)
|
|
|
|
data__hpp_register(d, PERF_HPP_DIFF__CYCLES_HIST);
|
|
|
|
|
2012-12-01 20:57:04 +00:00
|
|
|
/*
|
|
|
|
* And the rest:
|
|
|
|
*
|
|
|
|
* PERF_HPP_DIFF__FORMULA
|
|
|
|
* PERF_HPP_DIFF__PERIOD
|
|
|
|
* PERF_HPP_DIFF__PERIOD_BASELINE
|
|
|
|
*/
|
|
|
|
if (show_formula && i)
|
|
|
|
data__hpp_register(d, PERF_HPP_DIFF__FORMULA);
|
2012-10-05 14:44:45 +00:00
|
|
|
|
2012-12-01 20:57:04 +00:00
|
|
|
if (show_period)
|
|
|
|
data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
|
|
|
|
PERF_HPP_DIFF__PERIOD_BASELINE);
|
2012-10-05 14:44:44 +00:00
|
|
|
}
|
2015-01-08 00:45:48 +00:00
|
|
|
|
|
|
|
if (!sort_compute)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepend an fmt to sort on columns at 'sort_compute' first.
|
|
|
|
* This fmt is added only to the sort list but not to the
|
|
|
|
* output fields list.
|
|
|
|
*
|
|
|
|
* Note that this column (data) can be compared twice - one
|
|
|
|
* for this 'sort_compute' fmt and another for the normal
|
|
|
|
* diff_hpp_fmt. But it shouldn't a problem as most entries
|
|
|
|
* will be sorted out by first try or baseline and comparing
|
|
|
|
* is not a costly operation.
|
|
|
|
*/
|
|
|
|
fmt = zalloc(sizeof(*fmt));
|
|
|
|
if (fmt == NULL) {
|
|
|
|
pr_err("Memory allocation failed\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt->cmp = hist_entry__cmp_nop;
|
|
|
|
fmt->collapse = hist_entry__cmp_nop;
|
|
|
|
|
|
|
|
switch (compute) {
|
|
|
|
case COMPUTE_DELTA:
|
|
|
|
fmt->sort = hist_entry__cmp_delta_idx;
|
|
|
|
break;
|
|
|
|
case COMPUTE_RATIO:
|
|
|
|
fmt->sort = hist_entry__cmp_ratio_idx;
|
|
|
|
break;
|
|
|
|
case COMPUTE_WEIGHTED_DIFF:
|
|
|
|
fmt->sort = hist_entry__cmp_wdiff_idx;
|
|
|
|
break;
|
2017-02-10 07:36:11 +00:00
|
|
|
case COMPUTE_DELTA_ABS:
|
|
|
|
fmt->sort = hist_entry__cmp_delta_abs_idx;
|
|
|
|
break;
|
2019-06-28 09:23:01 +00:00
|
|
|
case COMPUTE_CYCLES:
|
|
|
|
/*
|
|
|
|
* Should set since 'fmt->sort' is called without
|
|
|
|
* checking valid during sorting
|
|
|
|
*/
|
|
|
|
fmt->sort = hist_entry__cmp_nop;
|
|
|
|
break;
|
2015-01-08 00:45:48 +00:00
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
2017-01-18 05:14:57 +00:00
|
|
|
perf_hpp__prepend_sort_field(fmt);
|
2015-01-08 00:45:48 +00:00
|
|
|
return 0;
|
2012-10-04 12:49:39 +00:00
|
|
|
}
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
static int data_init(int argc, const char **argv)
|
2009-12-14 22:09:31 +00:00
|
|
|
{
|
2013-03-24 23:02:01 +00:00
|
|
|
struct data__file *d;
|
|
|
|
static const char *defaults[] = {
|
|
|
|
"perf.data.old",
|
|
|
|
"perf.data",
|
|
|
|
};
|
2012-12-01 21:00:00 +00:00
|
|
|
bool use_default = true;
|
2013-03-24 23:02:01 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
data__files_cnt = 2;
|
|
|
|
|
2009-12-14 22:09:31 +00:00
|
|
|
if (argc) {
|
2012-12-01 21:00:00 +00:00
|
|
|
if (argc == 1)
|
2013-03-24 23:02:01 +00:00
|
|
|
defaults[1] = argv[0];
|
2012-12-01 21:00:00 +00:00
|
|
|
else {
|
|
|
|
data__files_cnt = argc;
|
|
|
|
use_default = false;
|
|
|
|
}
|
2013-12-06 22:25:52 +00:00
|
|
|
} else if (perf_guest) {
|
2013-03-24 23:02:01 +00:00
|
|
|
defaults[0] = "perf.data.host";
|
|
|
|
defaults[1] = "perf.data.guest";
|
2009-12-14 22:09:31 +00:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:10:20 +00:00
|
|
|
if (sort_compute >= (unsigned int) data__files_cnt) {
|
|
|
|
pr_err("Order option out of limit.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
data__files = zalloc(sizeof(*data__files) * data__files_cnt);
|
|
|
|
if (!data__files)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
data__for_each_file(i, d) {
|
2017-01-23 21:07:59 +00:00
|
|
|
struct perf_data *data = &d->data;
|
2013-10-15 14:27:32 +00:00
|
|
|
|
2019-02-21 09:41:30 +00:00
|
|
|
data->path = use_default ? defaults[i] : argv[i];
|
|
|
|
data->mode = PERF_DATA_MODE_READ,
|
|
|
|
data->force = force,
|
2013-10-15 14:27:32 +00:00
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
d->idx = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-02-10 07:36:12 +00:00
|
|
|
static int diff__config(const char *var, const char *value,
|
|
|
|
void *cb __maybe_unused)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "diff.order")) {
|
2017-06-27 14:44:58 +00:00
|
|
|
int ret;
|
|
|
|
if (perf_config_int(&ret, var, value) < 0)
|
|
|
|
return -1;
|
|
|
|
sort_compute = ret;
|
2017-02-10 07:36:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2017-02-10 07:36:13 +00:00
|
|
|
if (!strcmp(var, "diff.compute")) {
|
|
|
|
if (!strcmp(value, "delta")) {
|
|
|
|
compute = COMPUTE_DELTA;
|
|
|
|
} else if (!strcmp(value, "delta-abs")) {
|
|
|
|
compute = COMPUTE_DELTA_ABS;
|
|
|
|
} else if (!strcmp(value, "ratio")) {
|
|
|
|
compute = COMPUTE_RATIO;
|
|
|
|
} else if (!strcmp(value, "wdiff")) {
|
|
|
|
compute = COMPUTE_WEIGHTED_DIFF;
|
|
|
|
} else {
|
|
|
|
pr_err("Invalid compute method: %s\n", value);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2017-02-10 07:36:12 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-27 14:47:20 +00:00
|
|
|
int cmd_diff(int argc, const char **argv)
|
2013-03-24 23:02:01 +00:00
|
|
|
{
|
2014-10-22 19:02:41 +00:00
|
|
|
int ret = hists__init();
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-02-10 07:36:12 +00:00
|
|
|
perf_config(diff__config, NULL);
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
argc = parse_options(argc, argv, options, diff_usage, 0);
|
|
|
|
|
2017-02-17 08:17:40 +00:00
|
|
|
if (quiet)
|
|
|
|
perf_quiet_option();
|
|
|
|
|
2019-09-25 01:14:46 +00:00
|
|
|
if (cycles_hist && (compute != COMPUTE_CYCLES))
|
|
|
|
usage_with_options(diff_usage, options);
|
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (pdiff.stream)
|
|
|
|
compute = COMPUTE_STREAM;
|
|
|
|
|
2019-06-28 09:23:01 +00:00
|
|
|
symbol__annotation_init();
|
|
|
|
|
2014-08-12 06:40:45 +00:00
|
|
|
if (symbol__init(NULL) < 0)
|
2009-12-15 22:04:40 +00:00
|
|
|
return -1;
|
|
|
|
|
2013-03-24 23:02:01 +00:00
|
|
|
if (data_init(argc, argv) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2019-06-28 09:23:00 +00:00
|
|
|
if (check_file_brstack() < 0)
|
|
|
|
return -1;
|
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if ((compute == COMPUTE_CYCLES || compute == COMPUTE_STREAM)
|
|
|
|
&& !pdiff.has_br_stack) {
|
2019-06-28 09:23:01 +00:00
|
|
|
return -1;
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
}
|
2019-06-28 09:23:01 +00:00
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
if (compute == COMPUTE_STREAM) {
|
|
|
|
symbol_conf.show_branchflag_count = true;
|
|
|
|
symbol_conf.disable_add2line_warn = true;
|
|
|
|
callchain_param.mode = CHAIN_FLAT;
|
|
|
|
callchain_param.key = CCKEY_SRCLINE;
|
|
|
|
callchain_param.branch_callstack = 1;
|
|
|
|
symbol_conf.use_callchain = true;
|
|
|
|
callchain_register_param(&callchain_param);
|
|
|
|
sort_order = "srcline,symbol,dso";
|
|
|
|
} else {
|
|
|
|
if (ui_init() < 0)
|
|
|
|
return -1;
|
2012-10-04 12:49:39 +00:00
|
|
|
|
perf diff: Support hot streams comparison
This patch enables perf-diff with "--stream" option.
"--stream": Enable hot streams comparison
Now let's see example.
perf record -b ... Generate perf.data.old with branch data
perf record -b ... Generate perf.data with branch data
perf diff --stream
[ Matched hot streams ]
hot chain pair 1:
cycles: 1, hits: 27.77% cycles: 1, hits: 9.24%
--------------------------- --------------------------
main div.c:39 main div.c:39
main div.c:44 main div.c:44
hot chain pair 2:
cycles: 34, hits: 20.06% cycles: 27, hits: 16.98%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
__random_r random_r.c:357 __random_r random_r.c:357
__random random.c:293 __random random.c:293
__random random.c:293 __random random.c:293
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:291 __random random.c:291
__random random.c:288 __random random.c:288
rand rand.c:27 rand rand.c:27
rand rand.c:26 rand rand.c:26
rand@plt rand@plt
rand@plt rand@plt
compute_flag div.c:25 compute_flag div.c:25
compute_flag div.c:22 compute_flag div.c:22
main div.c:40 main div.c:40
main div.c:40 main div.c:40
main div.c:39 main div.c:39
hot chain pair 3:
cycles: 9, hits: 4.48% cycles: 6, hits: 4.51%
--------------------------- --------------------------
__random_r random_r.c:360 __random_r random_r.c:360
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:388 __random_r random_r.c:388
__random_r random_r.c:380 __random_r random_r.c:380
[ Hot streams in old perf data only ]
hot chain 1:
cycles: 18, hits: 6.75%
--------------------------
__random_r random_r.c:360
__random_r random_r.c:388
__random_r random_r.c:388
__random_r random_r.c:380
__random_r random_r.c:357
__random random.c:293
__random random.c:293
__random random.c:291
__random random.c:291
__random random.c:291
__random random.c:288
rand rand.c:27
rand rand.c:26
rand@plt
rand@plt
compute_flag div.c:25
compute_flag div.c:22
main div.c:40
hot chain 2:
cycles: 29, hits: 2.78%
--------------------------
compute_flag div.c:22
main div.c:40
main div.c:40
main div.c:39
[ Hot streams in new perf data only ]
hot chain 1:
cycles: 4, hits: 4.54%
--------------------------
main div.c:42
compute_flag div.c:28
hot chain 2:
cycles: 5, hits: 3.51%
--------------------------
main div.c:39
main div.c:44
main div.c:42
compute_flag div.c:28
Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20201009022845.13141-8-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-10-09 02:28:45 +00:00
|
|
|
sort__mode = SORT_MODE__DIFF;
|
|
|
|
}
|
2014-03-18 02:31:39 +00:00
|
|
|
|
2015-12-22 17:07:01 +00:00
|
|
|
if (setup_sorting(NULL) < 0)
|
2013-02-06 05:57:16 +00:00
|
|
|
usage_with_options(diff_usage, options);
|
|
|
|
|
2009-12-14 22:09:31 +00:00
|
|
|
setup_pager();
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 15:49:27 +00:00
|
|
|
|
2013-04-03 12:26:19 +00:00
|
|
|
sort__setup_elide(NULL);
|
perf diff: Use perf_session__fprintf_hists just like 'perf record'
That means that almost everything you can do with 'perf report'
can be done with 'perf diff', for instance:
$ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2699
samples) ] $ perf record -f find / > /dev/null
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.062 MB perf.data (~2687
samples) ] perf diff | head -8
9.02% +1.00% find libc-2.10.1.so [.] _IO_vfprintf_internal
2.91% -1.00% find [kernel] [k] __kmalloc
2.85% -1.00% find [kernel] [k] ext4_htree_store_dirent
1.99% -1.00% find [kernel] [k] _atomic_dec_and_lock
2.44% find [kernel] [k] half_md4_transform
$
So if you want to zoom into libc:
$ perf diff --dsos libc-2.10.1.so | head -8
37.34% find [.] _IO_vfprintf_internal
10.34% find [.] __GI_memmove
8.25% +2.00% find [.] _int_malloc
5.07% -1.00% find [.] __GI_mempcpy
7.62% +2.00% find [.] _int_free
$
And if there were multiple commands using libc, it is also
possible to aggregate them all by using --sort symbol:
$ perf diff --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% [.] __GI_mempcpy
7.62% +2.00% [.] _int_free
$
The displacement column now is off by default, to use it:
perf diff -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34% [.] _IO_vfprintf_internal
10.34% [.] __GI_memmove
8.25% +2.00% [.] _int_malloc
5.07% -1.00% +2 [.] __GI_mempcpy
7.62% +2.00% -1 [.] _int_free
$
Using -t/--field-separator can be used for scripting:
$ perf diff -t, -m --dsos libc-2.10.1.so --sort symbol | head -8
37.34, , ,[.] _IO_vfprintf_internal
10.34, , ,[.] __GI_memmove
8.25,+2.00%, ,[.] _int_malloc
5.07,-1.00%, +2,[.] __GI_mempcpy
7.62,+2.00%, -1,[.] _int_free
6.99,+1.00%, -1,[.] _IO_new_file_xsputn
1.89,-2.00%, +4,[.] __readdir64
$
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260978567-550-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-16 15:49:27 +00:00
|
|
|
|
2009-12-14 22:09:31 +00:00
|
|
|
return __cmd_diff();
|
|
|
|
}
|