perf_counter: Implement generalized cache event types
Subsystems (2)
Commit-ID: 8326f44da090d6d304d29b9fdc7fb3e20889e329 Gitweb: http://git.kernel.org/tip/8326f44da090d6d304d29b9fdc7fb3e20889e329 Author: Ingo Molnar <[email protected]> AuthorDate: Fri, 5 Jun 2009 20:22:46 +0200 Committer: Ingo Molnar <[email protected]> CommitDate: Sat, 6 Jun 2009 13:14:47 +0200
perf_counter: Implement generalized cache event types
Extend generic event enumeration with the PERF_TYPE_HW_CACHE method.
This is a 3-dimensional space:
{ L1-D, L1-I, L2, ITLB, DTLB, BPU } x
{ load, store, prefetch } x
{ accesses, misses }User-space passes in the 3 coordinates and the kernel provides a counter. (if the hardware supports that type and if the combination makes sense.)
Combinations that make no sense produce a -EINVAL. Combinations that are not supported by the hardware produce -ENOTSUP.
Extend the tools to deal with this, and rewrite the event symbol parsing code with various popular aliases for the units and access methods above. So 'l1-cache-miss' and 'l1d-read-ops' are both valid aliases.
( x86 is supported for now, with the Nehalem event table filled in,
and with Core2 and Atom having placeholder tables. )
Cc: Peter Zijlstra <[email protected]>
Cc: Mike Galbraith <[email protected]>
Cc: Paul Mackerras <[email protected]>
Cc: Corey Ashford <[email protected]>
Cc: Marcelo Tosatti <[email protected]>
Cc: Arnaldo Carvalho de Melo <[email protected]>
LKML-Reference: <new-submission>
--- Documentation/perf_counter/util/parse-events.c | 104 ++++++++++++- arch/x86/kernel/cpu/perf_counter.c | 201 +++++++++++++++++++++++- include/linux/perf_counter.h | 34 ++++ kernel/perf_counter.c | 1 + 4 files changed, 329 insertions(+), 11 deletions(-)
Documentation/perf_counter/util/parse-events.c +101 -3
@@ -6,6 +6,8 @@#include "exec_cmd.h" #include "string.h" +extern char *strcasestr (const char *haystack,const char *needle); +int nr_counters;struct perf_counter_attr attrs[MAX_COUNTERS ];
@@ -17,6 +19,7 @@ struct event_symbol { };#define C (x, y) .type = PERF_TYPE_##x, .config = PERF_COUNT_##y +#define CR (x, y) .type = PERF_TYPE_##x, .config = ystatic struct event_symbol event_symbols[] = { {C (HARDWARE ,CPU_CYCLES ),"cpu-cycles" , },
@@ -69,6 +72,28 @@ static char *sw_event_names[] = { "major faults", }; +#define MAX_ALIASES 8 + +static char *hw_cache [][MAX_ALIASES ] = { + {"l1-d" ,"l1d" ,"l1" ,"l1-data-cache" }, + {"l1-i" ,"l1i" ,"l1-instruction-cache" }, + {"l2" , }, + {"dtlb" , }, + {"itlb" , }, + {"bpu" ,"btb" ,"branch-cache" ,NULL }, +}; + +static char *hw_cache_op [][MAX_ALIASES ] = { + {"read" ,"load" }, + {"write" ,"store" }, + {"prefetch" ,"speculative-read" ,"speculative-load" }, +}; + +static char *hw_cache_result [][MAX_ALIASES ] = { + {"access" ,"ops" }, + {"miss" , }, +}; +char *event_name (int counter) {__u64 config = attrs[counter].config;
@@ -86,6 +111,30 @@ char *event_name(int counter)return hw_event_names[config];return "unknown-hardware" ; +case PERF_TYPE_HW_CACHE : { +__u8 cache_type, cache_op, cache_result; +static char name[100 ]; + + cache_type = (config >>0 ) &0xff ; +if (cache_type >PERF_COUNT_HW_CACHE_MAX ) +return "unknown-ext-hardware-cache-type" ; + + cache_op = (config >>8 ) &0xff ; +if (cache_type >PERF_COUNT_HW_CACHE_OP_MAX ) +return "unknown-ext-hardware-cache-op-type" ; + + cache_result = (config >>16 ) &0xff ; +if (cache_type >PERF_COUNT_HW_CACHE_RESULT_MAX ) +return "unknown-ext-hardware-cache-result-type" ; + +sprintf (name,"%s:%s:%s" , + hw_cache[cache_type][0 ], + hw_cache_op[cache_op][0 ], + hw_cache_result[cache_result][0 ]); + +return name; + } +case PERF_TYPE_SOFTWARE :if (config <PERF_SW_EVENTS_MAX )return sw_event_names[config];
@@ -98,11 +147,60 @@ char *event_name(int counter)return "unknown" ; } +static int parse_aliases (const char *str,char *names[][MAX_ALIASES ],int size) +{ +int i, j; + +for (i =0 ; i < size; i++) { +for (j =0 ; j <MAX_ALIASES ; j++) { +if (!names[i][j]) +break ; +if (strcasestr (str, names[i][j])) +return i; + } + } + +return 0 ; +} + +static int parse_generic_hw_symbols (const char *str,struct perf_counter_attr *attr) +{ +__u8 cache_type =-1 , cache_op =0 , cache_result =0 ; + + cache_type =parse_aliases (str, hw_cache,PERF_COUNT_HW_CACHE_MAX ); +/* +* No fallback - if we cannot get a clear cache type +* then bail out: +*/ +if (cache_type ==-1 ) +return -EINVAL ; + + cache_op =parse_aliases (str, hw_cache_op,PERF_COUNT_HW_CACHE_OP_MAX ); +/* +* Fall back to reads: +*/ +if (cache_type ==-1 ) + cache_type =PERF_COUNT_HW_CACHE_OP_READ ; + + cache_result =parse_aliases (str, hw_cache_result, +PERF_COUNT_HW_CACHE_RESULT_MAX ); +/* +* Fall back to accesses: +*/ +if (cache_result ==-1 ) + cache_result =PERF_COUNT_HW_CACHE_RESULT_ACCESS ; + + attr->config = cache_type | (cache_op <<8 ) | (cache_result <<16 ); + attr->type =PERF_TYPE_HW_CACHE ; + +return 0 ; +} +/* * Each event can have multiple symbolic names. * Symbolic names are (almost) exactly matched. */ -static int match_event_symbols (const char *str,struct perf_counter_attr *attr) +static int parse_event_symbols (const char *str,struct perf_counter_attr *attr) {__u64 config, id;int type;
@@ -147,7 +245,7 @@ static int match_event_symbols(const char *str, struct perf_counter_attr *attr) } } -return -EINVAL ; +return parse_generic_hw_symbols (str, attr); }int parse_events (const struct option *opt,const char *str,int unset)
@@ -160,7 +258,7 @@ again:if (nr_counters ==MAX_COUNTERS )return -1 ; - ret =match_event_symbols (str, &attr); + ret =parse_event_symbols (str, &attr);if (ret <0 )return ret;
arch/x86/kernel/cpu/perf_counter.c +193 -8
233 lines not on this page · raw message
include/linux/perf_counter.h +34 -0
@@ -28,6 +28,7 @@ enum perf_event_types {PERF_TYPE_HARDWARE =0 ,PERF_TYPE_SOFTWARE =1 ,PERF_TYPE_TRACEPOINT =2 , + PERF_TYPE_HW_CACHE = 3,/* * available TYPE space, raw is the max value.
@@ -56,6 +57,39 @@ enum attr_ids { };/* +* Generalized hardware cache counters: +* +* { L1-D, L1-I, L2, LLC, ITLB, DTLB, BPU } x +* { read, write, prefetch } x +* { accesses, misses } +*/ +enum hw_cache_id { +PERF_COUNT_HW_CACHE_L1D , +PERF_COUNT_HW_CACHE_L1I , +PERF_COUNT_HW_CACHE_L2 , +PERF_COUNT_HW_CACHE_DTLB , +PERF_COUNT_HW_CACHE_ITLB , +PERF_COUNT_HW_CACHE_BPU , + +PERF_COUNT_HW_CACHE_MAX , +}; + +enum hw_cache_op_id { +PERF_COUNT_HW_CACHE_OP_READ , +PERF_COUNT_HW_CACHE_OP_WRITE , +PERF_COUNT_HW_CACHE_OP_PREFETCH , + +PERF_COUNT_HW_CACHE_OP_MAX , +}; + +enum hw_cache_op_result_id { +PERF_COUNT_HW_CACHE_RESULT_ACCESS , +PERF_COUNT_HW_CACHE_RESULT_MISS , + +PERF_COUNT_HW_CACHE_RESULT_MAX , +}; + +/* * Special "software" counters provided by the kernel, even if the hardware * does not support performance counters. These counters measure various * physical and sw events of the kernel (and allow the profiling of them as
kernel/perf_counter.c +1 -0
@@ -3501,6 +3501,7 @@ perf_counter_alloc(struct perf_counter_attr *attr,switch (attr->type) {case PERF_TYPE_HARDWARE : +case PERF_TYPE_HW_CACHE : pmu =hw_perf_counter_init (counter);break ;
Quoted 68 lines · tip-bot for Ingo Molnar
Commit-ID: 8326f44da090d6d304d29b9fdc7fb3e20889e329 Gitweb: http://git.kernel.org/tip/8326f44da090d6d304d29b9fdc7fb3e20889e329 Author: Ingo Molnar <[email protected]> AuthorDate: Fri, 5 Jun 2009 20:22:46 +0200 Committer: Ingo Molnar <[email protected]> CommitDate: Sat, 6 Jun 2009 13:14:47 +0200
perf_counter: Implement generalized cache event typesExtend generic event enumeration with the
PERF_TYPE_HW_CACHEmethod.This is a 3-dimensional space:
{ L1-D, L1-I, L2, ITLB, DTLB, BPU } x { load, store, prefetch } x { accesses, misses }User-space passes in the 3 coordinates and the kernel provides a counter. (if the hardware supports that type and if the combination makes sense.)
Combinations that make no sense produce a
-EINVAL. Combinations that are not supported by the hardware produce-ENOTSUP.Extend the tools to deal with this, and rewrite the event symbol parsing code with various popular aliases for the units and access methods above. So 'l1-cache-miss' and 'l1d-read-ops' are both valid aliases.
( x86 is supported for now, with the Nehalem event table filled in,
and with Core2 and Atom having placeholder tables. )+++
b/include/linux/perf_counter.h(quoted diff) +22
-0@@ -28,6 +28,7 @@ enum perf_event_types { PERF_TYPE_HARDWARE = 0, PERF_TYPE_SOFTWARE = 1, PERF_TYPE_TRACEPOINT = 2, + PERF_TYPE_HW_CACHE = 3, /* * available TYPE space, raw is the max value.@@ -56,6 +57,39 @@ enum attr_ids { }; /* + * Generalized hardware cache counters: + * + * { L1-D, L1-I, L2, LLC, ITLB, DTLB, BPU } x + * { read, write, prefetch } x + * { accesses, misses } + */ +enum hw_cache_id { + PERF_COUNT_HW_CACHE_L1D, + PERF_COUNT_HW_CACHE_L1I, + PERF_COUNT_HW_CACHE_L2, + PERF_COUNT_HW_CACHE_DTLB, + PERF_COUNT_HW_CACHE_ITLB, + PERF_COUNT_HW_CACHE_BPU, + + PERF_COUNT_HW_CACHE_MAX, +}; + +enum hw_cache_op_id { + PERF_COUNT_HW_CACHE_OP_READ, + PERF_COUNT_HW_CACHE_OP_WRITE, + PERF_COUNT_HW_CACHE_OP_PREFETCH,
Review enum attr_ids { · line 90
Quoted 10 lines
(quoted diff) +10
-0+ + PERF_COUNT_HW_CACHE_OP_MAX, +}; + +enum hw_cache_op_result_id { + PERF_COUNT_HW_CACHE_RESULT_ACCESS, + PERF_COUNT_HW_CACHE_RESULT_MISS, + + PERF_COUNT_HW_CACHE_RESULT_MAX, +};
May I suggest we do the below instead? Some hardware doesn't make the read/write distinction and would therefore have an utterly empty table.
Furthermore, also splitting the hit/miss into a bitfield allows us to have hit/miss and the combined value.
---
include/linux/perf_counter.h +16 -13
@@ -64,29 +64,32 @@ enum attr_ids {* { accesses, misses } */ enum hw_cache_id { -PERF_COUNT_HW_CACHE_L1D , -PERF_COUNT_HW_CACHE_L1I , -PERF_COUNT_HW_CACHE_L2 , -PERF_COUNT_HW_CACHE_DTLB , -PERF_COUNT_HW_CACHE_ITLB , -PERF_COUNT_HW_CACHE_BPU , +PERF_COUNT_HW_CACHE_L1D =0 , +PERF_COUNT_HW_CACHE_L1I =1 , +PERF_COUNT_HW_CACHE_L2 =2 , +PERF_COUNT_HW_CACHE_DTLB =3 , +PERF_COUNT_HW_CACHE_ITLB =4 , +PERF_COUNT_HW_CACHE_BPU =5 ,PERF_COUNT_HW_CACHE_MAX , };enum hw_cache_op_id { -PERF_COUNT_HW_CACHE_OP_READ , -PERF_COUNT_HW_CACHE_OP_WRITE , -PERF_COUNT_HW_CACHE_OP_PREFETCH , +PERF_COUNT_HW_CACHE_OP_READ =0x1 , +PERF_COUNT_HW_CACHE_OP_WRITE =0x2 , +PERF_COUNT_HW_CACHE_OP_ACCESS =0x3 ,/* either READ or WRITE */ +PERF_COUNT_HW_CACHE_OP_PREFETCH =0x4 ,/* XXX should we qualify this with either READ/WRITE? */ -PERF_COUNT_HW_CACHE_OP_MAX , + +PERF_COUNT_HW_CACHE_OP_MAX =0x8 , };enum hw_cache_op_result_id { -PERF_COUNT_HW_CACHE_RESULT_ACCESS , -PERF_COUNT_HW_CACHE_RESULT_MISS , +PERF_COUNT_HW_CACHE_RESULT_HIT =0x1 , +PERF_COUNT_HW_CACHE_RESULT_MISS =0x2 , +PERF_COUNT_HW_CACHE_RESULT_SUM =0x3 , -PERF_COUNT_HW_CACHE_RESULT_MAX , +PERF_COUNT_HW_CACHE_RESULT_MAX =0x4 , };/*
Quoted 97 lines · Peter Zijlstra
Quoted 68 lines · tip-bot for Ingo Molnar
Commit-ID: 8326f44da090d6d304d29b9fdc7fb3e20889e329 Gitweb: http://git.kernel.org/tip/8326f44da090d6d304d29b9fdc7fb3e20889e329 Author: Ingo Molnar <[email protected]> AuthorDate: Fri, 5 Jun 2009 20:22:46 +0200 Committer: Ingo Molnar <[email protected]> CommitDate: Sat, 6 Jun 2009 13:14:47 +0200
perf_counter: Implement generalized cache event typesExtend generic event enumeration with the
PERF_TYPE_HW_CACHEmethod.This is a 3-dimensional space:
{ L1-D, L1-I, L2, ITLB, DTLB, BPU } x { load, store, prefetch } x { accesses, misses }User-space passes in the 3 coordinates and the kernel provides a counter. (if the hardware supports that type and if the combination makes sense.)
Combinations that make no sense produce a
-EINVAL. Combinations that are not supported by the hardware produce-ENOTSUP.Extend the tools to deal with this, and rewrite the event symbol parsing code with various popular aliases for the units and access methods above. So 'l1-cache-miss' and 'l1d-read-ops' are both valid aliases.
( x86 is supported for now, with the Nehalem event table filled in,
and with Core2 and Atom having placeholder tables. )+++
b/include/linux/perf_counter.h(quoted diff) +22
-0@@ -28,6 +28,7 @@ enum perf_event_types { PERF_TYPE_HARDWARE = 0, PERF_TYPE_SOFTWARE = 1, PERF_TYPE_TRACEPOINT = 2, + PERF_TYPE_HW_CACHE = 3, /* * available TYPE space, raw is the max value.@@ -56,6 +57,39 @@ enum attr_ids { }; /* + * Generalized hardware cache counters: + * + * { L1-D, L1-I, L2, LLC, ITLB, DTLB, BPU } x + * { read, write, prefetch } x + * { accesses, misses } + */ +enum hw_cache_id { + PERF_COUNT_HW_CACHE_L1D, + PERF_COUNT_HW_CACHE_L1I, + PERF_COUNT_HW_CACHE_L2, + PERF_COUNT_HW_CACHE_DTLB, + PERF_COUNT_HW_CACHE_ITLB, + PERF_COUNT_HW_CACHE_BPU, + + PERF_COUNT_HW_CACHE_MAX, +}; + +enum hw_cache_op_id { + PERF_COUNT_HW_CACHE_OP_READ, + PERF_COUNT_HW_CACHE_OP_WRITE, + PERF_COUNT_HW_CACHE_OP_PREFETCH,Review enum attr_ids { · line 90
Quoted 10 lines
(quoted diff) +10
-0+ + PERF_COUNT_HW_CACHE_OP_MAX, +}; + +enum hw_cache_op_result_id { + PERF_COUNT_HW_CACHE_RESULT_ACCESS, + PERF_COUNT_HW_CACHE_RESULT_MISS, + + PERF_COUNT_HW_CACHE_RESULT_MAX, +};May I suggest we do the below instead? Some hardware doesn't make the read/write distinction and would therefore have an utterly empty table.
Furthermore, also splitting the hit/miss into a bitfield allows us to have hit/miss and the combined value.
---
include/linux/perf_counter.h +0
-2@@ -64,29 +64,32 @@ enum attr_ids {* { accesses, misses } */ enum hw_cache_id { -PERF_COUNT_HW_CACHE_L1D , -PERF_COUNT_HW_CACHE_L1I ,
include/linux/perf_counter.h enum attr_ids { · line 72
Quoted 10 lines
include/linux/perf_counter.h +6
-4-PERF_COUNT_HW_CACHE_L2 , -PERF_COUNT_HW_CACHE_DTLB , -PERF_COUNT_HW_CACHE_ITLB , - PERF_COUNT_HW_CACHE_BPU, +PERF_COUNT_HW_CACHE_L1D =0 , +PERF_COUNT_HW_CACHE_L1I =1 , +PERF_COUNT_HW_CACHE_L2 =2 , +PERF_COUNT_HW_CACHE_DTLB =3 , +PERF_COUNT_HW_CACHE_ITLB =4 , + PERF_COUNT_HW_CACHE_BPU = 5,
Could you please also rename 'L2' to LLC (last level cache)?
We want to know about the fastest and the 'largest' caches. Intermediate caches are a lot less interesting in practice, and we dont really want to enumerate a variable number of cache levels.
include/linux/perf_counter.h enum attr_ids { · line 81
Quoted 11 lines
include/linux/perf_counter.h +4
-3PERF_COUNT_HW_CACHE_MAX, };enum hw_cache_op_id { -PERF_COUNT_HW_CACHE_OP_READ , -PERF_COUNT_HW_CACHE_OP_WRITE , -PERF_COUNT_HW_CACHE_OP_PREFETCH , +PERF_COUNT_HW_CACHE_OP_READ =0x1 , +PERF_COUNT_HW_CACHE_OP_WRITE =0x2 , +PERF_COUNT_HW_CACHE_OP_ACCESS =0x3 ,/* either READ or WRITE */ +PERF_COUNT_HW_CACHE_OP_PREFETCH =0x4 ,/* XXX should we qualify this with either READ/WRITE? */
Btw., could you please also rename the constants to LOAD/STORE? That's the proper PMU terminology.
Prefetches are basically almost always reads. That comes from the physical fact that they can be done speculatively without modifying memory state. A 'speculative write', while possible in theory, would have so many side effects, and would complicate the SMP caching algorithm and an in-order execution model enormously, so i doubt it will be done in any widespread way anytime soon.
Nevertheless, turning it into a bit does make sense, from an ABI cleanliness POV.
include/linux/perf_counter.h enum attr_ids { · line 90
Quoted 12 lines
include/linux/perf_counter.h +5
-3- PERF_COUNT_HW_CACHE_OP_MAX, + + PERF_COUNT_HW_CACHE_OP_MAX = 0x8, };enum hw_cache_op_result_id { -PERF_COUNT_HW_CACHE_RESULT_ACCESS , -PERF_COUNT_HW_CACHE_RESULT_MISS , +PERF_COUNT_HW_CACHE_RESULT_HIT =0x1 , +PERF_COUNT_HW_CACHE_RESULT_MISS =0x2 , +PERF_COUNT_HW_CACHE_RESULT_SUM =0x3 ,
RESULT_SUM sounds a bit weird - perhaps RESULT_ANY or RESULT_ALL?
Ingo