Skip to contentSkip to conversation

A mechanism for efficient support for per-function metrics

PATCH Superseded [email protected] 2 participants 15 messages Mar 7, 2025 – Mar 12, 2025

Subsystems (3)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v3 cover A mechanism for efficient support for per-function metrics

From: Mark Barnett <[email protected]>

This patch introduces the concept of an alternating sample rate to perf core and provides the necessary basic changes in the tools to activate that option.

The primary use case for this change is to be able to enable collecting per-function performance metrics using the Arm PMU, as per the following approach:

* Starting with a simple periodic sampling (hotspot) profile, augment each sample with PMU counters accumulated over a short window up to the point the sample was taken.
* For each sample, perform some filtering to improve attribution of the accumulated PMU counters (ensure they are attributed to a single function)
* For each function accumulate a total for each PMU counter so that metrics may be derived.

Without modification, and sampling at a typical rate associated with hotspot profiling (~1mS) leads to poor results. Such an approach gives you a reasonable estimation of where the profiled application is spending time for relatively low overhead, but the PMU counters cannot easily be attributed to a single function as the window over which they are collected is too large. A modern CPU may execute many millions of instructions over many thousands of functions within 1mS window. With this approach, the per-function metrics tend to trend to some average value across the top N functions in the profile.

In order to ensure a reasonable likelihood that the counters are attributed to a single function, the sampling window must be rather short; typically something in the order of a few hundred cycles proves well as tested on a range of aarch64 Cortex and Neoverse cores.

As it stands, it is possible to achieve this with perf using a very high sampling rate (e.g ~300cy), but there are at least three major concerns with this approach:

* For speculatively executing, out of order cores, can the results be accurately attributed to a give function or the given sample window?
* A short sample window is not guaranteed to cover a single function.
* The overhead of sampling every few hundred cycles is very high and is highly likely to cause throttling which is undesirable as it leads to patchy results; i.e. the profile alternates between periods of high frequency samples followed by longer periods of no samples.

This patch does not address the first two points directly. Some means to address those are discussed on the RFC v2 cover letter. The patch focuses on addressing the final point, though happily this approach gives us a way to perform basic filtering on the second point.

The alternating sample period allows us to do two things:

* We can control the risk of throttling and reduce overhead by alternating between a long and short period. This allows us to decouple the "periodic" sampling rate (as might be used for hotspot profiling) from the short sampling window needed for collecting the PMU counters.
* The sample taken at the end of the long period can be otherwise discarded (as the PMU data is not useful), but the PERF_RECORD_CALLCHAIN information can be used to identify the current function at the start of the short sample window. This is useful for filtering samples where the PMU counter data cannot be attributed to a single function.

There are several reasons why it is desirable to reduce the overhead and risk of throttling:

* PMU counter overflow typically causes an interrupt into the kernel; this affects program runtime, and can affect things like branch prediction, cache locality and so on which can skew the metrics.
* The very high sample rate produces significant amounts of data. Depending on the configuration of the profiling session and machine, it is easily possible to produce many orders of magnitude more data which is costly for tools to post-process and increases the chance of data loss. This is especially relevant on larger core count systems where it is very easy to produce massive recordings. Whilst the kernel will throttle such a configuration, which helps to mitigate a large portion of the bandwidth and capture overhead, it is not something that can be controlled for on a per event basis, or for non-root users, and because throttling is controlled as a percentage of time its affects vary from machine to machine. AIUI throttling may also produce an uneven temporal distribution of samples. Finally, whilst throttling does a good job at reducing the overall amount of data produced, it still leads to much larger captures than with this method; typically we have observed 1-2 orders of magnitude larger captures.

This patch set modifies perf core to support alternating between two sample_period values, providing a simple and inexpensive way for tools to separate out the sample window (time over which events are counted) from the sample period (time between interesting samples).

It is expected to be used with the cycle counter event, alternating between a long and short period and subsequently discarding the counter data for samples with the long period. The combined long and short period gives the overall sampling period, and the short sample period gives the sample window. The symbol taken from the sample at the end of the long period can be used by tools to ensure correct attribution as described previously. The cycle counter is recommended as it provides fair temporal distribution of samples as would be required for the per-symbol sample count mentioned previously, and because the PMU can be programmed to overflow after a sufficiently short window (which may not be possible with software timer, for example). This patch does not restrict to only the cycle counter, it is possible there could be other novel uses based on different events, or more appropriate counters on other architectures. This patch set does not modify or otherwise disable the kernel's existing throttling behaviour; if a configuration is given that would lead high CPU usage, then throttling still occurs.

To test this a simple perf script based python script was developed. For a limited set of Arm PMU events it will post process a perf record-ing and generate a table of metrics. Along side this a benchmark application was developed that rotates through a sequence of different classes of behaviour that can be detected by the Arm PMU (eg. mispredicts, cache misses, different instruction mixes). The path through the benchmark can be rotated after each iteration so as to ensure the results don't land on some lucky harmonic with the sample period. The script can be used with and without this patch allowing comparison of the results. Testing was on Juno (A53+A57), N1SDP, Gravaton 2 and 3. In addition this approach has been applied to a few of Arm's tools projects and has correctly identified improvements and regressions.

Headline results from testing indicate that ~300 cycles sample window gives good results with or without this patch. Typical output on N1SDP (Neoverse-N1) for the provided benchmark when run as:

    perf record -T --sample-cpu --call-graph fp,4 --user-callchains \
        -k CLOCK_MONOTONIC_RAW \
        -e '{cycles/period=999700,alt-period=300/,instructions,branch-misses,cache-references,cache-misses}:uS' \
        benchmark 0 1

    perf script -s generate-function-metrics.py -- -s discard

Looks like (reformatted for email brevity):

    Symbol              #     CPI   BM/KI  CM/KI  %CM   %CY   %I    %BM   %L1DA  %L1DM
    fp_divider_stalls   6553   4.9   0.0     0.0   0.0  41.8  22.9   0.1   0.6    0.0
    int_divider_stalls  4741   3.5   0.0     0.0   1.1  28.3  21.5   0.1   1.9    0.2
    isb                 3414  20.1   0.2     0.0   0.4  17.6   2.3   0.1   0.8    0.0
    branch_mispredicts  1234   1.1  33.0     0.0   0.0   6.1  15.2  99.0  71.6    0.1
    double_to_int        694   0.5   0.0     0.0   0.6   3.4  19.1   0.1   1.2    0.1
    nops                 417   0.3   0.2     0.0   2.8   1.9  18.3   0.6   0.4    0.1
    dcache_miss          185   3.6   0.4   184.7  53.8   0.7   0.5   0.0  18.4   99.1

(CPI = Cycles/Instruction, BM/KI = Branch Misses per 1000 Instruction,
CM/KI = Cache Misses per 1000 Instruction, %CM = Percent of Cache accesses that miss, %CY = Percentage of total cycles, %I = Percentage of total instructions, %BM = Percentage of total branch mispredicts, %L1DA = Percentage of total cache accesses, %L1DM = Percentage of total cache misses)

When the patch is used, the resulting perf.data files are typically between 25-50x smaller than without, and take ~25x less time for the python script to post-process. For example, running the following:

perf record -i -vvv -e '{cycles/period=1000000/,instructions}:uS' benchmark 0 1 perf record -i -vvv -e '{cycles/period=1000/,instructions}:uS' benchmark 0 1 perf record -i -vvv -e '{cycles/period=300/,instructions}:uS' benchmark 0 1

produces captures on N1SDP (Neoverse-N1) of the following sizes:

* period=1000000: 2.601 MB perf.data (55780 samples), script time = 0m0.362s
* period=1000: 283.749 MB perf.data (6162932 samples), script time = 0m33.100s
* period=300: 304.281 MB perf.data (6614182 samples), script time = 0m35.826s

The "script time" is the user time from running "time perf script -s generate-function-metrics.py" on the recording. Similar processing times were observed for "time perf report --stdio|cat" as well.

By comparison, with the patch active:

    perf record -i -vvv -e '{cycles/period=999700,alt-period=300/,instructions}:uS' benchmark 0 1

produces 4.923 MB perf.data (107512 samples), and script time = 0m0.578s. Which is as expected ~2x the size and ~2x the number of samples as per the period=1000000 recording. When compared to the period=300 recording, the results from the provided post-processing script are (within margin of error) the same, but the data file is ~62x smaller. The same affect is seen for the post-processing script runtime.

Notably, without the patch enable, L1D cache miss rates are often higher than with, which we attribute to increased impact on the cache that trapping into the kernel every 300 cycles has.

These results are given with perf_cpu_time_max_percent=25. When tested with perf_cpu_time_max_percent=100 the size and time comparisons are more significant. Disabling throttling did not lead to obvious improvements in the collected metrics, suggesting that the sampling approach is sufficient to collect representative metrics.

Cursory testing on a Xeon(R) W-2145 with a 300 *instruction* sample window (with and without the patch) suggests this approach might work for some counters. Using the same test script, it was possible to identify branch mispredicts correctly. However, whilst the patch is functionally correct, differences in the architectures may mean that this approach it enables does not apply as a means to collect per-function metrics on x86.

Changes since v2:
- Rebased onto latest perf-tools-next.
- Reordered patch series so that "Record sample last_period before updating" applies first.
- Addressed issue reported by LKP tests.
- Addressed review comments from Leo Yan.

Changes since v1:
- Rebased onto perf-tools-next, as per request from Ian Rogers.
- Removed unnecessary code that truncated period_left to 0 and restarted the PMU.
- Renamed variables to use the shorter 'alt_period' instead of 'alterantive_period'.
- Addressed review comments from Leo Yan.
- Added patch #5 that addresses an issue in the x86 and PowerPC drivers that caused the opposite period to be reported in the sample record.

Changes since RFC v2:
- Rebased on v6.12-rc6.

Changes since RFC v1:
- Rebased on v6.9-rc1.
- Refactored from arm_pmu based extension to core feature
- Added the ability to jitter the sample window based on feedback from Andi Kleen.
- Modified perf tool to parse the "alt-period" and "alt-period-jitter" terms in the event specification.

Ben Gainey (4):
perf: Allow periodic events to alternate between two sample periods
perf: Allow adding fixed random jitter to the alternate sampling
period
tools/perf: Modify event parser to support alt-period term tools/perf: Modify event parser to support alt-period-jitter term

Mark Barnett (1):
perf: Record sample last_period before updating

 arch/powerpc/perf/core-book3s.c               |  3 +-
 arch/powerpc/perf/core-fsl-emb.c              |  3 +-
 arch/x86/events/core.c                        |  4 +-
 arch/x86/events/intel/core.c                  |  5 ++-
 arch/x86/events/intel/knc.c                   |  4 +-
 include/linux/perf_event.h                    |  5 +++
 include/uapi/linux/perf_event.h               | 10 ++++-
 kernel/events/core.c                          | 44 ++++++++++++++++++-
 tools/include/uapi/linux/perf_event.h         | 10 ++++-
 tools/perf/tests/shell/attr/base-record       |  4 +-
 tools/perf/tests/shell/attr/base-record-spe   |  2 +
 tools/perf/tests/shell/attr/base-stat         |  4 +-
 tools/perf/tests/shell/attr/system-wide-dummy |  4 +-
 .../attr/test-record-alt-period-jitter-term   | 13 ++++++
 .../shell/attr/test-record-alt-period-term    | 12 +++++
 .../tests/shell/attr/test-record-dummy-C0     |  4 +-
 tools/perf/tests/shell/lib/attr.py            |  2 +
 tools/perf/util/evsel.c                       |  2 +
 tools/perf/util/parse-events.c                | 30 +++++++++++++
 tools/perf/util/parse-events.h                |  4 +-
 tools/perf/util/parse-events.l                |  2 +
 tools/perf/util/perf_event_attr_fprintf.c     |  1 +
 tools/perf/util/pmu.c                         |  4 +-
 23 files changed, 162 insertions(+), 14 deletions(-)
 create mode 100644 tools/perf/tests/shell/attr/test-record-alt-period-jitter-term
 create mode 100644 tools/perf/tests/shell/attr/test-record-alt-period-term
Signature · 1 line
2.43.0
#1 lore raw

PATCH v3 1/5 perf: Record sample last_period before updating

From: Mark Barnett <[email protected]>

This change alters the PowerPC and x86 driver implementations to record the last sample period before the event is updated for the next period.

A common pattern in PMU driver implementations is to have a "*_event_set_period" function which takes care of updating the various period-related fields in a perf_event structure. In most cases, the drivers choose to call this function after initializing a sample data structure with perf_sample_data_init. The x86 and PowerPC drivers deviate from this, choosing to update the period before initializing the sample data. When using an event with an alternate sample period, this causes an incorrect period to be written to the sample data that gets reported to userspace.

---
 arch/powerpc/perf/core-book3s.c  | 3 ++-
 arch/powerpc/perf/core-fsl-emb.c | 3 ++-
 arch/x86/events/core.c           | 4 +++-
 arch/x86/events/intel/core.c     | 5 ++++-
 arch/x86/events/intel/knc.c      | 4 +++-
 5 files changed, 14 insertions(+), 5 deletions(-)
arch/powerpc/perf/core-book3s.c +2 -1
index 2b79171ee185..234803441caa 100644
@@ -2231,6 +2231,7 @@ static void record_and_restart(struct perf_event *event, unsigned long val,
 			       struct pt_regs *regs)
 {
 	u64 period = event->hw.sample_period;
+	const u64 last_period = event->hw.last_period;
 	s64 prev, delta, left;
 	int record = 0;
 
@@ -2296,7 +2297,7 @@ static void record_and_restart(struct perf_event *event, unsigned long val,
 	if (record) {
 		struct perf_sample_data data;
 
-		perf_sample_data_init(&data, ~0ULL, event->hw.last_period);
+		perf_sample_data_init(&data, ~0ULL, last_period);
 
 		if (event->attr.sample_type & PERF_SAMPLE_ADDR_TYPE)
 			perf_get_data_addr(event, regs, &data.addr);
arch/powerpc/perf/core-fsl-emb.c +2 -1
index 1a53ab08447c..d2ffcc7021c5 100644
@@ -590,6 +590,7 @@ static void record_and_restart(struct perf_event *event, unsigned long val,
 			       struct pt_regs *regs)
 {
 	u64 period = event->hw.sample_period;
+	const u64 last_period = event->hw.last_period;
 	s64 prev, delta, left;
 	int record = 0;
 
@@ -632,7 +633,7 @@ static void record_and_restart(struct perf_event *event, unsigned long val,
 	if (record) {
 		struct perf_sample_data data;
 
-		perf_sample_data_init(&data, 0, event->hw.last_period);
+		perf_sample_data_init(&data, 0, last_period);
 
 		if (perf_event_overflow(event, &data, regs))
 			fsl_emb_pmu_stop(event, 0);
arch/x86/events/core.c +3 -1
index 8f218ac0d445..a78a8f3244ef 100644
@@ -1673,6 +1673,7 @@ int x86_pmu_handle_irq(struct pt_regs *regs)
 	struct cpu_hw_events *cpuc;
 	struct perf_event *event;
 	int idx, handled = 0;
+	u64 last_period;
 	u64 val;
 
 	cpuc = this_cpu_ptr(&cpu_hw_events);
@@ -1692,6 +1693,7 @@ int x86_pmu_handle_irq(struct pt_regs *regs)
 			continue;
 
 		event = cpuc->events[idx];
+		last_period = event->hw.last_period;
 
 		val = static_call(x86_pmu_update)(event);
 		if (val & (1ULL << (x86_pmu.cntval_bits - 1)))
@@ -1705,7 +1707,7 @@ int x86_pmu_handle_irq(struct pt_regs *regs)
 		if (!static_call(x86_pmu_set_period)(event))
 			continue;
 
-		perf_sample_data_init(&data, 0, event->hw.last_period);
+		perf_sample_data_init(&data, 0, last_period);
 
 		perf_sample_save_brstack(&data, event, &cpuc->lbr_stack, NULL);
 
arch/x86/events/intel/core.c +4 -1
index 7601196d1d18..add791c6e3d9 100644
@@ -3116,16 +3116,19 @@ static int handle_pmi_common(struct pt_regs *regs, u64 status)
 
 	for_each_set_bit(bit, (unsigned long *)&status, X86_PMC_IDX_MAX) {
 		struct perf_event *event = cpuc->events[bit];
+		u64 last_period;
 
 		handled++;
 
 		if (!test_bit(bit, cpuc->active_mask))
 			continue;
 
+		last_period = event->hw.last_period;
+
 		if (!intel_pmu_save_and_restart(event))
 			continue;
 
-		perf_sample_data_init(&data, 0, event->hw.last_period);
+		perf_sample_data_init(&data, 0, last_period);
 
 		if (has_branch_stack(event))
 			intel_pmu_lbr_save_brstack(&data, cpuc, event);
arch/x86/events/intel/knc.c +3 -1
index 034a1f6a457c..3e8ec049b46d 100644
@@ -241,16 +241,18 @@ static int knc_pmu_handle_irq(struct pt_regs *regs)
 
 	for_each_set_bit(bit, (unsigned long *)&status, X86_PMC_IDX_MAX) {
 		struct perf_event *event = cpuc->events[bit];
+		u64 last_period;
 
 		handled++;
 
 		if (!test_bit(bit, cpuc->active_mask))
 			continue;
 
+		last_period = event->hw.last_period;
 		if (!intel_pmu_save_and_restart(event))
 			continue;
 
-		perf_sample_data_init(&data, 0, event->hw.last_period);
+		perf_sample_data_init(&data, 0, last_period);
 
 		if (perf_event_overflow(event, &data, regs))
 			x86_pmu_stop(event, 0);
Signature · 1 line
2.43.0
#2 lore raw

PATCH v3 2/5 perf: Allow periodic events to alternate between two sample periods

In reply to [email protected]

From: Ben Gainey <[email protected]>

This change modifies perf_event_attr to add a second, alternative sample period field, and modifies the core perf overflow handling such that when specified an event will alternate between two sample periods.

Currently, perf does not provide a mechanism for decoupling the period over which counters are counted from the period between samples. This is problematic for building a tool to measure per-function metrics derived from a sampled counter group. Ideally such a tool wants a very small sample window in order to correctly attribute the metrics to a given function, but prefers a larger sample period that provides representative coverage without excessive probe effect, triggering throttling, or generating excessive amounts of data.

By alternating between a long and short sample_period and subsequently discarding the long samples, tools may decouple the period between samples that the tool cares about from the window of time over which interesting counts are collected.

It is expected that typically tools would use this feature with the cycles or instructions events as an approximation for time, but no restrictions are applied to which events this can be applied to.

---
 include/linux/perf_event.h      |  5 +++++
 include/uapi/linux/perf_event.h |  3 +++
 kernel/events/core.c            | 39 ++++++++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 1 deletion(-)
include/linux/perf_event.h +5 -0
index 8333f132f4a9..99ba72c8fb6d 100644
@@ -276,6 +276,11 @@ struct hw_perf_event {
 	 */
 	u64				freq_time_stamp;
 	u64				freq_count_stamp;
+
+	/*
+	 * Indicates that the alternative sample period is used
+	 */
+	bool				using_alt_sample_period;
 #endif
 };
 
include/uapi/linux/perf_event.h +3 -0
index 0524d541d4e3..499a8673df8e 100644
@@ -379,6 +379,7 @@ enum perf_event_read_format {
 #define PERF_ATTR_SIZE_VER6	120	/* add: aux_sample_size */
 #define PERF_ATTR_SIZE_VER7	128	/* add: sig_data */
 #define PERF_ATTR_SIZE_VER8	136	/* add: config3 */
+#define PERF_ATTR_SIZE_VER9	144	/* add: alt_sample_period */
 
 /*
  * Hardware event_id to monitor via a performance monitoring event:
@@ -531,6 +532,8 @@ struct perf_event_attr {
 	__u64	sig_data;
 
 	__u64	config3; /* extension of config2 */
+
+	__u64	alt_sample_period;
 };
 
 /*
kernel/events/core.c +38 -1
index bcb09e011e9e..7ec8ec6ba7ef 100644
@@ -4178,6 +4178,8 @@ static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bo
 	s64 period, sample_period;
 	s64 delta;
 
+	WARN_ON_ONCE(hwc->using_alt_sample_period);
+
 	period = perf_calculate_period(event, nsec, count);
 
 	delta = (s64)(period - hwc->sample_period);
@@ -9894,6 +9896,7 @@ static int __perf_event_overflow(struct perf_event *event,
 				 int throttle, struct perf_sample_data *data,
 				 struct pt_regs *regs)
 {
+	struct hw_perf_event *hwc = &event->hw;
 	int events = atomic_read(&event->event_limit);
 	int ret = 0;
 
@@ -9913,6 +9916,18 @@ static int __perf_event_overflow(struct perf_event *event,
 	    !bpf_overflow_handler(event, data, regs))
 		goto out;
 
+	/*
+	 * Swap the sample period to the alternative period
+	 */
+	if (event->attr.alt_sample_period) {
+		bool using_alt = hwc->using_alt_sample_period;
+		u64 sample_period = (using_alt ? event->attr.sample_period
+					       : event->attr.alt_sample_period);
+
+		hwc->sample_period = sample_period;
+		hwc->using_alt_sample_period = !using_alt;
+	}
+
 	/*
 	 * XXX event_limit might not quite work as expected on inherited
 	 * events
@@ -12335,9 +12350,19 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
 	if (attr->freq && attr->sample_freq)
 		hwc->sample_period = 1;
 	hwc->last_period = hwc->sample_period;
-
 	local64_set(&hwc->period_left, hwc->sample_period);
 
+	/*
+	 * alt_sample_period cannot be used with freq
+	 */
+	if (attr->freq && attr->alt_sample_period)
+		goto err_ns;
+
+	if (attr->alt_sample_period) {
+		hwc->sample_period = attr->alt_sample_period;
+		hwc->using_alt_sample_period = true;
+	}
+
 	/*
 	 * We do not support PERF_SAMPLE_READ on inherited events unless
 	 * PERF_SAMPLE_TID is also selected, which allows inherited events to
@@ -12807,9 +12832,21 @@ SYSCALL_DEFINE5(perf_event_open,
 	if (attr.freq) {
 		if (attr.sample_freq > sysctl_perf_event_sample_rate)
 			return -EINVAL;
+		if (attr.alt_sample_period)
+			return -EINVAL;
 	} else {
 		if (attr.sample_period & (1ULL << 63))
 			return -EINVAL;
+		if (attr.alt_sample_period) {
+			if (!attr.sample_period)
+				return -EINVAL;
+			if (attr.alt_sample_period & (1ULL << 63))
+				return -EINVAL;
+			if (attr.alt_sample_period > attr.sample_period)
+				return -EINVAL;
+			if (attr.alt_sample_period == attr.sample_period)
+				attr.alt_sample_period = 0;
+		}
 	}
 
 	/* Only privileged users can get physical addresses */
Signature · 1 line
2.43.0
maintainer
#3 lore raw

Re: [PATCH v3 2/5] perf: Allow periodic events to alternate between two sample periods

Quoted 16 lines · On Fri, Mar 07, 2025 at 08:22:44PM +0000, [email protected] wrote:

From: Ben Gainey <[email protected]>

This change modifies perf_event_attr to add a second, alternative sample period field, and modifies the core perf overflow handling such that when specified an event will alternate between two sample periods.

Currently, perf does not provide a mechanism for decoupling the period over which counters are counted from the period between samples. This is problematic for building a tool to measure per-function metrics derived from a sampled counter group. Ideally such a tool wants a very small sample window in order to correctly attribute the metrics to a given function, but prefers a larger sample period that provides representative coverage without excessive probe effect, triggering throttling, or generating excessive amounts of data.

Quoted 8 lines

By alternating between a long and short sample_period and subsequently discarding the long samples, tools may decouple the period between samples that the tool cares about from the window of time over which interesting counts are collected.

It is expected that typically tools would use this feature with the cycles or instructions events as an approximation for time, but no restrictions are applied to which events this can be applied to.

So you do add the constraint that 'alt_sample_period < sample_period' but there is no natural reason for this to be so.

Additionally, this way the total period ends up being 'sample_period + alt_sample_period'.

Would not a more natural way to express things be:

	p1 = sample_period - alt_sample_period;
	p2 = alt_sample_period;

This way you retain the total period to be 'sample_period' and naturally get the constraint: 'alt_sample_period < sample_period'.

That is; I'm somewhat confused by the state of things; it doesn't seem consistent.

(Also note that this alternative form might actually work in combination with attr.freq set -- although that has a number of 'fun' details I'm sure).

Quoted 13 lines
---
 include/linux/perf_event.h      |  5 +++++
 include/uapi/linux/perf_event.h |  3 +++
 kernel/events/core.c            | 39 ++++++++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 1 deletion(-)
include/linux/perf_event.h +0 -0
index 8333f132f4a9..99ba72c8fb6d 100644

include/linux/perf_event.h struct hw_perf_event { · line 283

Quoted 8 lines
include/linux/perf_event.h +5 -0
@@ -276,6 +276,11 @@ struct hw_perf_event {
 	 */
 	u64				freq_time_stamp;
 	u64				freq_count_stamp;
+
+	/*
+	 * Indicates that the alternative sample period is used
+	 */
+	bool				using_alt_sample_period;

There's a 4 byte hole in this structure if you look; also please use a flag, sizeof(_Bool) is ABI dependent.

Quoted 29 lines
include/linux/perf_event.h +0 -0
 #endif
 };
 
include/uapi/linux/perf_event.h +3 -0
index 0524d541d4e3..499a8673df8e 100644
@@ -379,6 +379,7 @@ enum perf_event_read_format {
 #define PERF_ATTR_SIZE_VER6	120	/* add: aux_sample_size */
 #define PERF_ATTR_SIZE_VER7	128	/* add: sig_data */
 #define PERF_ATTR_SIZE_VER8	136	/* add: config3 */
+#define PERF_ATTR_SIZE_VER9	144	/* add: alt_sample_period */
 
 /*
  * Hardware event_id to monitor via a performance monitoring event:
@@ -531,6 +532,8 @@ struct perf_event_attr {
 	__u64	sig_data;
 
 	__u64	config3; /* extension of config2 */
+
+	__u64	alt_sample_period;
 };
 
 /*
kernel/events/core.c +0 -0
index bcb09e011e9e..7ec8ec6ba7ef 100644

kernel/events/core.c static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bo · line 4181

Quoted 4 lines
kernel/events/core.c +1 -0
@@ -4178,6 +4178,8 @@ static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bo
 	s64 period, sample_period;
 	s64 delta;
 
+	WARN_ON_ONCE(hwc->using_alt_sample_period);

Groan; so that bit keeps flipping in and off, and statistically we'll warn, but urgh.

Quoted 32 lines
kernel/events/core.c +13 -0
 	period = perf_calculate_period(event, nsec, count);
 
 	delta = (s64)(period - hwc->sample_period);
@@ -9894,6 +9896,7 @@ static int __perf_event_overflow(struct perf_event *event,
 				 int throttle, struct perf_sample_data *data,
 				 struct pt_regs *regs)
 {
+	struct hw_perf_event *hwc = &event->hw;
 	int events = atomic_read(&event->event_limit);
 	int ret = 0;
 
@@ -9913,6 +9916,18 @@ static int __perf_event_overflow(struct perf_event *event,
 	    !bpf_overflow_handler(event, data, regs))
 		goto out;
 
+	/*
+	 * Swap the sample period to the alternative period
+	 */
+	if (event->attr.alt_sample_period) {
+		bool using_alt = hwc->using_alt_sample_period;
+		u64 sample_period = (using_alt ? event->attr.sample_period
+					       : event->attr.alt_sample_period);
+
+		hwc->sample_period = sample_period;
+		hwc->using_alt_sample_period = !using_alt;
+	}
+
 	/*
 	 * XXX event_limit might not quite work as expected on inherited
 	 * events
@@ -12335,9 +12350,19 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
 	if (attr->freq && attr->sample_freq)

kernel/events/core.c perf_event_alloc(struct perf_event_attr *attr, int cpu, · line 12359

Quoted 10 lines
kernel/events/core.c +5 -1
 		hwc->sample_period = 1;
 	hwc->last_period = hwc->sample_period;
-
 	local64_set(&hwc->period_left, hwc->sample_period);
 
+	/*
+	 * alt_sample_period cannot be used with freq
+	 */
+	if (attr->freq && attr->alt_sample_period)
+		goto err_ns;

How can this happen? This case has already been filtered in perf_event_open() below, no?

Also, this doesn't apply to tip/perf/core, someone went and changed things...

Quoted 34 lines
kernel/events/core.c +18 -0
+
+	if (attr->alt_sample_period) {
+		hwc->sample_period = attr->alt_sample_period;
+		hwc->using_alt_sample_period = true;
+	}
+
 	/*
 	 * We do not support PERF_SAMPLE_READ on inherited events unless
 	 * PERF_SAMPLE_TID is also selected, which allows inherited events to
@@ -12807,9 +12832,21 @@ SYSCALL_DEFINE5(perf_event_open,
 	if (attr.freq) {
 		if (attr.sample_freq > sysctl_perf_event_sample_rate)
 			return -EINVAL;
+		if (attr.alt_sample_period)
+			return -EINVAL;
 	} else {
 		if (attr.sample_period & (1ULL << 63))
 			return -EINVAL;
+		if (attr.alt_sample_period) {
+			if (!attr.sample_period)
+				return -EINVAL;
+			if (attr.alt_sample_period & (1ULL << 63))
+				return -EINVAL;
+			if (attr.alt_sample_period > attr.sample_period)
+				return -EINVAL;
+			if (attr.alt_sample_period == attr.sample_period)
+				attr.alt_sample_period = 0;
+		}
 	}
 
 	/* Only privileged users can get physical addresses */
Signature · 1 line
2.43.0
#4 lore raw

PATCH v3 3/5 perf: Allow adding fixed random jitter to the alternate sampling period

In reply to [email protected]

From: Ben Gainey <[email protected]>

This change modifies the core perf overflow handler, adding some small random jitter to each sample period whenever an event switches between the two alternate sample periods. A new flag is added to perf_event_attr to opt into this behaviour.

This change follows the discussion in [1], where it is recognized that it may be possible for certain patterns of execution to end up with biased results.

[1] https://lore.kernel.org/linux-perf-users/Zc24eLqZycmIg3d2@tassilo/

---
 include/uapi/linux/perf_event.h | 7 ++++++-
 kernel/events/core.c            | 9 ++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)
include/uapi/linux/perf_event.h +6 -1
index 499a8673df8e..c0076ce8f80a 100644
@@ -461,7 +461,12 @@ struct perf_event_attr {
 				inherit_thread :  1, /* children only inherit if cloned with CLONE_THREAD */
 				remove_on_exec :  1, /* event is removed from task on exec */
 				sigtrap        :  1, /* send synchronous SIGTRAP on event */
-				__reserved_1   : 26;
+				/*
+				 * Add a limited amount of jitter on each alternate period, where
+				 * the jitter is between [0, (2<<jitter_alt_period) - 1]
+				 */
+				jitter_alt_period : 3,
+				__reserved_1   : 23;
 
 	union {
 		__u32		wakeup_events;	  /* wakeup every n events */
kernel/events/core.c +8 -1
index 7ec8ec6ba7ef..be271e21cd06 100644
@@ -15,6 +15,7 @@
 #include <linux/idr.h>
 #include <linux/file.h>
 #include <linux/poll.h>
+#include <linux/random.h>
 #include <linux/slab.h>
 #include <linux/hash.h>
 #include <linux/tick.h>
@@ -9922,7 +9923,10 @@ static int __perf_event_overflow(struct perf_event *event,
 	if (event->attr.alt_sample_period) {
 		bool using_alt = hwc->using_alt_sample_period;
 		u64 sample_period = (using_alt ? event->attr.sample_period
-					       : event->attr.alt_sample_period);
+					       : event->attr.alt_sample_period)
+				  + (event->attr.jitter_alt_period
+					? get_random_u32_below(2 << event->attr.jitter_alt_period)
+					: 0);
 
 		hwc->sample_period = sample_period;
 		hwc->using_alt_sample_period = !using_alt;
@@ -12849,6 +12853,9 @@ SYSCALL_DEFINE5(perf_event_open,
 		}
 	}
 
+	if (attr.jitter_alt_period && !attr.alt_sample_period)
+		return -EINVAL;
+
 	/* Only privileged users can get physical addresses */
 	if ((attr.sample_type & PERF_SAMPLE_PHYS_ADDR)) {
 		err = perf_allow_kernel(&attr);
Signature · 1 line
2.43.0
maintainer
#5 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

kernel/events/core.c static int __perf_event_overflow(struct perf_event *event, · line 9929

Quoted 9 lines · On Fri, Mar 07, 2025 at 08:22:45PM +0000, [email protected] wrote:
kernel/events/core.c +4 -1
@@ -9922,7 +9923,10 @@ static int __perf_event_overflow(struct perf_event *event,
 	if (event->attr.alt_sample_period) {
 		bool using_alt = hwc->using_alt_sample_period;
 		u64 sample_period = (using_alt ? event->attr.sample_period
-					       : event->attr.alt_sample_period);
+					       : event->attr.alt_sample_period)
+				  + (event->attr.jitter_alt_period
+					? get_random_u32_below(2 << event->attr.jitter_alt_period)
+					: 0);

So, ... this here is NMI context, right? Have you looked at the guts of get_random_u32_below() ?

I would strongly suggest you go do so.

Quoted 3 lines
kernel/events/core.c +0 -0
 		hwc->sample_period = sample_period;
 		hwc->using_alt_sample_period = !using_alt;
#6 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

Quoted 14 lines · Peter Zijlstra

kernel/events/core.c static int __perf_event_overflow(struct perf_event *event, · line 9929

Quoted 9 lines · On Fri, Mar 07, 2025 at 08:22:45PM +0000, [email protected] wrote:
kernel/events/core.c +4 -1
@@ -9922,7 +9923,10 @@ static int __perf_event_overflow(struct perf_event *event,
  	if (event->attr.alt_sample_period) {
  		bool using_alt = hwc->using_alt_sample_period;
  		u64 sample_period = (using_alt ? event->attr.sample_period
-					       : event->attr.alt_sample_period);
+					       : event->attr.alt_sample_period)
+				  + (event->attr.jitter_alt_period
+					? get_random_u32_below(2 << event->attr.jitter_alt_period)
+					: 0);

So, ... this here is NMI context, right? Have you looked at the guts of get_random_u32_below() ?

Quoted 2 lines

I would strongly suggest you go do so.

Good catch. I think a pseudo-random generator would be fine here and it looks like the implementation of prandom is safe to use in an interrupt context. I can change to use that.

Quoted 3 lines
Quoted 3 lines
kernel/events/core.c +0 -0
  		hwc->sample_period = sample_period;
  		hwc->using_alt_sample_period = !using_alt;
maintainer
#7 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

In reply to [email protected]
Quoted 25 lines · On Fri, Mar 07, 2025 at 08:22:45PM +0000, [email protected] wrote:

From: Ben Gainey <[email protected]>

This change modifies the core perf overflow handler, adding some small random jitter to each sample period whenever an event switches between the two alternate sample periods. A new flag is added to perf_event_attr to opt into this behaviour.

This change follows the discussion in [1], where it is recognized that it may be possible for certain patterns of execution to end up with biased results.

[1] https://lore.kernel.org/linux-perf-users/Zc24eLqZycmIg3d2@tassilo/

---
 include/uapi/linux/perf_event.h | 7 ++++++-
 kernel/events/core.c            | 9 ++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)
include/uapi/linux/perf_event.h +0 -0
index 499a8673df8e..c0076ce8f80a 100644

include/uapi/linux/perf_event.h struct perf_event_attr { · line 469

Quoted 10 lines
include/uapi/linux/perf_event.h +6 -1
@@ -461,7 +461,12 @@ struct perf_event_attr {
 				inherit_thread :  1, /* children only inherit if cloned with CLONE_THREAD */
 				remove_on_exec :  1, /* event is removed from task on exec */
 				sigtrap        :  1, /* send synchronous SIGTRAP on event */
-				__reserved_1   : 26;
+				/*
+				 * Add a limited amount of jitter on each alternate period, where
+				 * the jitter is between [0, (2<<jitter_alt_period) - 1]
+				 */
+				jitter_alt_period : 3,
+				__reserved_1   : 23;

So; I've been thinking about this interface.

I think I prefer you keep the existing sample_period/sample_freq working as is and simply modulate with random and high-freq components.

A very little like so..

I've made the hf_sample_period 32bit since I figured that ought to be enough -- you're aiming at very short periods after all. But there's enough unused bits left.

So this has sample_period or sample_freq compute hwc->sample_period_base which is first modified with random such that the average is exactly sample_period_base (assuming a flat distribution).

This means that sample_period_base is still the right number to use for computing freq based things. Additionally, have the 'extra' interrupt ignored for adaptive period crud.

Also, someone needs to consider the eBPF hook and what to do with it. I've kept the ordering as per this series, but I suspect it's wrong and we want this before the BPF hook. Please think about this and explicitly mention this in the next series.

Anyway, very much a sketch of things, incomplete and not been near a compiler.

---

include/linux/perf_event.h +5 -0
index 76f4265efee9..c5dd6442e96f 100644
@@ -229,6 +229,10 @@ struct hw_perf_event {
 #define PERF_HES_UPTODATE	0x02 /* event->count up-to-date */
 #define PERF_HES_ARCH		0x04
 
+#define PERF_HES_HF_ON		0x10 /* using high-fred sampling */
+#define PERF_HES_HF_SAMPLE	0x20
+#define PERF_HES_HF_RAND	0x40
+
 	int				state;
 
 	/*
@@ -241,6 +245,7 @@ struct hw_perf_event {
 	 * The period to start the next sample with.
 	 */
 	u64				sample_period;
+	u64				sample_period_base;
 
 	union {
 		struct { /* Sampling */
include/uapi/linux/perf_event.h +9 -0
index 0524d541d4e3..8dbe027f93f1 100644
@@ -379,6 +379,7 @@ enum perf_event_read_format {
 #define PERF_ATTR_SIZE_VER6	120	/* add: aux_sample_size */
 #define PERF_ATTR_SIZE_VER7	128	/* add: sig_data */
 #define PERF_ATTR_SIZE_VER8	136	/* add: config3 */
+#define PERF_ATTR_SIZE_VER9	144	/* add: hf_sample */
 
 /*
  * Hardware event_id to monitor via a performance monitoring event:
@@ -531,6 +532,14 @@ struct perf_event_attr {
 	__u64	sig_data;
 
 	__u64	config3; /* extension of config2 */
+	union {
+		__u64 hf_sample;
+		struct {
+			__u64 hf_sample_period : 32,
+			      hf_sample_rand   :  4,
+			      __reserved_4     : 28;
+		};
+	};
 };
 
 /*
kernel/events/core.c +54 -5

138 lines not on this page · raw message

maintainer
#8 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

kernel/events/core.c line 14

Quoted 12 lines · Peter Zijlstra
kernel/events/core.c +1 -0
index b87a5ac42ce2..e5a93edf3b5f 100644
@@ -8,6 +8,7 @@
  *  Copyright  ©  2009 Paul Mackerras, IBM Corp. <[email protected]>
  */
 
+#include "linux/random.h"
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>

Argh, this is neovim trying to be 'helpful'. If anybody reading this knows how to make it stop adding headers, please let me know, its driving me nuts.

maintainer
#9 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

Quoted 9 lines · Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
kernel/events/core.c +0 -0
index b87a5ac42ce2..e5a93edf3b5f 100644
@@ -8,6 +8,7 @@
  *  Copyright  ©  2009 Paul Mackerras, IBM Corp. <[email protected]>
  */
 
Quoted 8 lines

kernel/events/core.c line 14

Quoted 4 lines
kernel/events/core.c +1 -0
+#include "linux/random.h"
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>

Argh, this is neovim trying to be 'helpful'. If anybody reading this knows how to make it stop adding headers, please let me know, its driving me nuts.

Adding this cmd thing to the lspconfig like so:

require 'lspconfig'.clangd.setup() {
	cmd = {
		"clangd",
		"--header-insertion=never",
	},
}

seems to do the trick.

maintainer
#10 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

In reply to Peter Zijlstra
Quoted 10 lines · Peter Zijlstra
kernel/events/core.c +10 -0
+	sample_period = hwc->sample_period_base;
+	if (hwc->state & PERF_HES_HF_RAND) {
+		u64 rand = 1 << event->attr.hf_sample_rand;
+		sample_period -= rand / 2;
+		sample_period += prandom_u32_state(&perf_rand) & (rand - 1);
+	}
+	if (hwc->state & PERF_HES_HF_ON) {
+		u64 hf_sample_period = event->attr.hf_sample_period;
+
+		if (sample_period < hf_sample_period) {

kernel/events/core.c static int __perf_event_overflow(struct perf_event *event, · line 10038

Quoted 10 lines
kernel/events/core.c +10 -0
+			hwc->state &= ~PERF_HES_HF_ON;
+			goto set_period;
+		}
+
+		if (!(hwc->state & PERF_HES_HF_SAMPLE)) {
+			hwc->sample_period -= hf_sample_period;
+			hwc->state |= PERF_HES_HF_SAMPLE;
+		} else {
+			hwc->sample_period = hf_sample_period;
+			hwc->state &= ~PERF_HES_HF_SAMPLE;

and obviously this should be the local sample_period modified above, not the hwc one.

Quoted 4 lines
kernel/events/core.c +4 -0
+		}
+	}
+set_period:
+	hwc->sample_period = sample_period;
#11 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

In reply to Peter Zijlstra
Quoted 56 lines · Peter Zijlstra
Quoted 25 lines · On Fri, Mar 07, 2025 at 08:22:45PM +0000, [email protected] wrote:

From: Ben Gainey <[email protected]>

This change modifies the core perf overflow handler, adding some small random jitter to each sample period whenever an event switches between the two alternate sample periods. A new flag is added to perf_event_attr to opt into this behaviour.

This change follows the discussion in [1], where it is recognized that it may be possible for certain patterns of execution to end up with biased results.

[1] https://lore.kernel.org/linux-perf-users/Zc24eLqZycmIg3d2@tassilo/

---
  include/uapi/linux/perf_event.h | 7 ++++++-
  kernel/events/core.c            | 9 ++++++++-
  2 files changed, 14 insertions(+), 2 deletions(-)
include/uapi/linux/perf_event.h +0 -0
index 499a8673df8e..c0076ce8f80a 100644

include/uapi/linux/perf_event.h struct perf_event_attr { · line 469

Quoted 10 lines
include/uapi/linux/perf_event.h +6 -1
@@ -461,7 +461,12 @@ struct perf_event_attr {
  				inherit_thread :  1, /* children only inherit if cloned with CLONE_THREAD */
  				remove_on_exec :  1, /* event is removed from task on exec */
  				sigtrap        :  1, /* send synchronous SIGTRAP on event */
-				__reserved_1   : 26;
+				/*
+				 * Add a limited amount of jitter on each alternate period, where
+				 * the jitter is between [0, (2<<jitter_alt_period) - 1]
+				 */
+				jitter_alt_period : 3,
+				__reserved_1   : 23;

So; I've been thinking about this interface.

I think I prefer you keep the existing sample_period/sample_freq working as is and simply modulate with random and high-freq components.

A very little like so..

I've made the hf_sample_period 32bit since I figured that ought to be enough -- you're aiming at very short periods after all. But there's enough unused bits left.

So this has sample_period or sample_freq compute hwc->sample_period_base which is first modified with random such that the average is exactly sample_period_base (assuming a flat distribution).

This means that sample_period_base is still the right number to use for computing freq based things. Additionally, have the 'extra' interrupt ignored for adaptive period crud.

Quoted 9 lines

Also, someone needs to consider the eBPF hook and what to do with it. I've kept the ordering as per this series, but I suspect it's wrong and we want this before the BPF hook. Please think about this and explicitly mention this in the next series.

Anyway, very much a sketch of things, incomplete and not been near a compiler.

Thanks, Peter!

OK, I see what you mean. Packing the fields into hf_sample makes sense. I'll have a look at the eBPF hook and see if we need to do anything. The sample period is always stored in perf_sample_data so it's technically possible for eBPF programs to identify the high-frequency ones, but it's not a great API. Maybe we should have an explicit flag.

I have one question about interrupt accounting, below...

Quoted 128 lines

---

include/linux/perf_event.h +5 -0
index 76f4265efee9..c5dd6442e96f 100644
@@ -229,6 +229,10 @@ struct hw_perf_event {
  #define PERF_HES_UPTODATE	0x02 /* event->count up-to-date */
  #define PERF_HES_ARCH		0x04
 
+#define PERF_HES_HF_ON		0x10 /* using high-fred sampling */
+#define PERF_HES_HF_SAMPLE	0x20
+#define PERF_HES_HF_RAND	0x40
+
  	int				state;
 
  	/*
@@ -241,6 +245,7 @@ struct hw_perf_event {
  	 * The period to start the next sample with.
  	 */
  	u64				sample_period;
+	u64				sample_period_base;
 
  	union {
  		struct { /* Sampling */
include/uapi/linux/perf_event.h +9 -0
index 0524d541d4e3..8dbe027f93f1 100644
@@ -379,6 +379,7 @@ enum perf_event_read_format {
  #define PERF_ATTR_SIZE_VER6	120	/* add: aux_sample_size */
  #define PERF_ATTR_SIZE_VER7	128	/* add: sig_data */
  #define PERF_ATTR_SIZE_VER8	136	/* add: config3 */
+#define PERF_ATTR_SIZE_VER9	144	/* add: hf_sample */
 
  /*
   * Hardware event_id to monitor via a performance monitoring event:
@@ -531,6 +532,14 @@ struct perf_event_attr {
  	__u64	sig_data;
 
  	__u64	config3; /* extension of config2 */
+	union {
+		__u64 hf_sample;
+		struct {
+			__u64 hf_sample_period : 32,
+			      hf_sample_rand   :  4,
+			      __reserved_4     : 28;
+		};
+	};
  };
 
  /*
kernel/events/core.c +12 -4
index b87a5ac42ce2..e5a93edf3b5f 100644
@@ -8,6 +8,7 @@
   *  Copyright  ©  2009 Paul Mackerras, IBM Corp. <[email protected]>
   */
 
+#include "linux/random.h"
  #include <linux/fs.h>
  #include <linux/mm.h>
  #include <linux/cpu.h>
@@ -55,6 +56,7 @@
  #include <linux/pgtable.h>
  #include <linux/buildid.h>
  #include <linux/task_work.h>
+#include <linux/prandom.h>
 
  #include "internal.h"
 
@@ -443,6 +445,8 @@ static cpumask_var_t perf_online_pkg_mask;
  static cpumask_var_t perf_online_sys_mask;
  static struct kmem_cache *perf_event_cache;
 
+static struct rnd_state perf_rand;
+
  /*
   * perf event paranoia level:
   *  -1 - not paranoid at all
@@ -4233,19 +4237,19 @@ static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bo
 
  	period = perf_calculate_period(event, nsec, count);
 
-	delta = (s64)(period - hwc->sample_period);
+	delta = (s64)(period - hwc->sample_period_base);
  	if (delta >= 0)
  		delta += 7;
  	else
  		delta -= 7;
  	delta /= 8; /* low pass filter */
 
-	sample_period = hwc->sample_period + delta;
+	sample_period = hwc->sample_period_base + delta;
 
  	if (!sample_period)
  		sample_period = 1;
 
-	hwc->sample_period = sample_period;
+	hwc->sample_period_base = sample_period;
 
  	if (local64_read(&hwc->period_left) > 8*sample_period) {
  		if (disable)
@@ -4490,6 +4494,8 @@ void perf_event_task_tick(void)
  	if (ctx)
  		perf_adjust_freq_unthr_context(ctx, !!throttled);
  	rcu_read_unlock();
+
+	prandom_seed_state(&perf_rand, get_random_u64());
  }
 
  static int event_enable_on_exec(struct perf_event *event,
@@ -9979,6 +9985,8 @@ static int __perf_event_overflow(struct perf_event *event,
  				 int throttle, struct perf_sample_data *data,
  				 struct pt_regs *regs)
  {
+	struct hw_perf_event *hwc = &event->hw;
+	u64 sample_period;
  	int events = atomic_read(&event->event_limit);
  	int ret = 0;
 
@@ -9989,15 +9997,50 @@ static int __perf_event_overflow(struct perf_event *event,
  	if (unlikely(!is_sampling_event(event)))
  		return 0;
 
-	ret = __perf_event_account_interrupt(event, throttle);
+	/*

kernel/events/core.c static int __perf_event_overflow(struct perf_event *event, · line 10010

Quoted 10 lines
kernel/events/core.c +9 -0
+	 * High Freq samples are injected inside the larger period:
+	 *
+	 *   |------------|-|------------|-|
+	 *   P0          HF P1          HF
+	 *
+	 * By ignoring the HF samples, we measure the actual period.
+	 */
+	if (!(hwc->state & PERF_HES_HF_SAMPLE))
+		ret = __perf_event_account_interrupt(event, throttle);
 

The high-frequency samples should still contribute to interrupt accounting/throttling, right? We'd just need to put guards around the adaptive period stuff so that HF samples don't contribute to the frequency training.

Quoted 67 lines
kernel/events/core.c +33 -1
  	if (event->attr.aux_pause)
  		perf_event_aux_pause(event->aux_event, true);
 
+	/* XXX interaction between HF samples and BPF */
  	if (event->prog && event->prog->type == BPF_PROG_TYPE_PERF_EVENT &&
  	    !bpf_overflow_handler(event, data, regs))
  		goto out;
 
+	sample_period = hwc->sample_period_base;
+	if (hwc->state & PERF_HES_HF_RAND) {
+		u64 rand = 1 << event->attr.hf_sample_rand;
+		sample_period -= rand / 2;
+		sample_period += prandom_u32_state(&perf_rand) & (rand - 1);
+	}
+	if (hwc->state & PERF_HES_HF_ON) {
+		u64 hf_sample_period = event->attr.hf_sample_period;
+
+		if (sample_period < hf_sample_period) {
+			hwc->state &= ~PERF_HES_HF_ON;
+			goto set_period;
+		}
+
+		if (!(hwc->state & PERF_HES_HF_SAMPLE)) {
+			hwc->sample_period -= hf_sample_period;
+			hwc->state |= PERF_HES_HF_SAMPLE;
+		} else {
+			hwc->sample_period = hf_sample_period;
+			hwc->state &= ~PERF_HES_HF_SAMPLE;
+		}
+	}
+set_period:
+	hwc->sample_period = sample_period;
+
  	/*
  	 * XXX event_limit might not quite work as expected on inherited
  	 * events
@@ -12458,8 +12501,11 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
 
  	hwc = &event->hw;
  	hwc->sample_period = attr->sample_period;
-	if (attr->freq && attr->sample_freq)
+	hwc->sample_period_base = attr->sample_period;
+	if (attr->freq && attr->sample_freq) {
  		hwc->sample_period = 1;
+		hwc->sample_period_base = 1;
+	}
  	hwc->last_period = hwc->sample_period;
 
  	local64_set(&hwc->period_left, hwc->sample_period);
@@ -13824,6 +13870,7 @@ inherit_event(struct perf_event *parent_event,
  		struct hw_perf_event *hwc = &child_event->hw;
 
  		hwc->sample_period = sample_period;
+		hwc->sample_period_base = sample_period;
  		hwc->last_period   = sample_period;
 
  		local64_set(&hwc->period_left, sample_period);
@@ -14279,6 +14326,8 @@ void __init perf_event_init(void)
  {
  	int ret;
 
+	prandom_seed_state(&perf_rand, get_random_u64());
+
  	idr_init(&pmu_idr);
 
  	perf_event_init_all_cpus();
maintainer
#12 lore raw

Re: [PATCH v3 3/5] perf: Allow adding fixed random jitter to the alternate sampling period

Quoted 19 lines · Mark Barnett
Quoted 19 lines
kernel/events/core.c +9 -1
@@ -9979,6 +9985,8 @@ static int __perf_event_overflow(struct perf_event *event,
  				 int throttle, struct perf_sample_data *data,
  				 struct pt_regs *regs)
  {
+	struct hw_perf_event *hwc = &event->hw;
+	u64 sample_period;
  	int events = atomic_read(&event->event_limit);
  	int ret = 0;
@@ -9989,15 +9997,50 @@ static int __perf_event_overflow(struct perf_event *event,
  	if (unlikely(!is_sampling_event(event)))
  		return 0;
-	ret = __perf_event_account_interrupt(event, throttle);
+	/*
+	 * High Freq samples are injected inside the larger period:
+	 *
+	 *   |------------|-|------------|-|
+	 *   P0          HF P1          HF
+	 *
+	 * By ignoring the HF samples, we measure the actual period.
Quoted 8 lines

kernel/events/core.c static int __perf_event_overflow(struct perf_event *event, · line 10009

Quoted 3 lines
kernel/events/core.c +3 -0
+	 */
+	if (!(hwc->state & PERF_HES_HF_SAMPLE))
+		ret = __perf_event_account_interrupt(event, throttle);

The high-frequency samples should still contribute to interrupt accounting/throttling, right? We'd just need to put guards around the adaptive period stuff so that HF samples don't contribute to the frequency training.

Yeah, I suppose it should. This means breaking up that function but that isn't hard.

#13 lore raw

PATCH v3 4/5 tools/perf: Modify event parser to support alt-period term

In reply to [email protected]

From: Ben Gainey <[email protected]>

parse-events is modified, adding the "alt-period" term which can be used to specify the alternative sampling period.

---
 tools/include/uapi/linux/perf_event.h             |  3 +++
 tools/perf/tests/shell/attr/base-record           |  3 ++-
 tools/perf/tests/shell/attr/base-record-spe       |  1 +
 tools/perf/tests/shell/attr/base-stat             |  3 ++-
 tools/perf/tests/shell/attr/system-wide-dummy     |  3 ++-
 .../tests/shell/attr/test-record-alt-period-term  | 12 ++++++++++++
 tools/perf/tests/shell/attr/test-record-dummy-C0  |  3 ++-
 tools/perf/tests/shell/lib/attr.py                |  1 +
 tools/perf/util/evsel.c                           |  1 +
 tools/perf/util/parse-events.c                    | 15 +++++++++++++++
 tools/perf/util/parse-events.h                    |  3 ++-
 tools/perf/util/parse-events.l                    |  1 +
 tools/perf/util/perf_event_attr_fprintf.c         |  1 +
 tools/perf/util/pmu.c                             |  1 +
 14 files changed, 46 insertions(+), 5 deletions(-)
 create mode 100644 tools/perf/tests/shell/attr/test-record-alt-period-term
tools/include/uapi/linux/perf_event.h +3 -0
index 0524d541d4e3..499a8673df8e 100644
@@ -379,6 +379,7 @@ enum perf_event_read_format {
 #define PERF_ATTR_SIZE_VER6	120	/* add: aux_sample_size */
 #define PERF_ATTR_SIZE_VER7	128	/* add: sig_data */
 #define PERF_ATTR_SIZE_VER8	136	/* add: config3 */
+#define PERF_ATTR_SIZE_VER9	144	/* add: alt_sample_period */
 
 /*
  * Hardware event_id to monitor via a performance monitoring event:
@@ -531,6 +532,8 @@ struct perf_event_attr {
 	__u64	sig_data;
 
 	__u64	config3; /* extension of config2 */
+
+	__u64	alt_sample_period;
 };
 
 /*
tools/perf/tests/shell/attr/base-record +2 -1
index b44e4e6e4443..28a7233f7bc1 100644
@@ -5,7 +5,7 @@ group_fd=-1
 flags=0|8
 cpu=*
 type=0|1
-size=136
+size=144
 config=0|1
 sample_period=*
 sample_type=263
@@ -39,3 +39,4 @@ config2=0
 branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
+alt_sample_period=0
tools/perf/tests/shell/attr/base-record-spe +1 -0
index 08fa96b59240..ad8eb72e655a 100644
@@ -38,3 +38,4 @@ config2=*
 branch_sample_type=*
 sample_regs_user=*
 sample_stack_user=*
+alt_sample_period=0
tools/perf/tests/shell/attr/base-stat +2 -1
index fccd8ec4d1b0..2de92c5c300d 100644
@@ -5,7 +5,7 @@ group_fd=-1
 flags=0|8
 cpu=*
 type=0
-size=136
+size=144
 config=0
 sample_period=0
 sample_type=65536
@@ -39,3 +39,4 @@ config2=0
 branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
+alt_sample_period=0
tools/perf/tests/shell/attr/system-wide-dummy +2 -1
index a1e1d6a263bf..c0a17bb3c022 100644
@@ -7,7 +7,7 @@ cpu=*
 pid=-1
 flags=8
 type=1
-size=136
+size=144
 config=9
 sample_period=1
 # PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME |
@@ -50,3 +50,4 @@ config2=0
 branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
+alt_sample_period=0
tools/perf/tests/shell/attr/test-record-alt-period-term new file +12 -0
new file mode 100644
index 000000000000..fcdb790adcd3
@@ -0,0 +1,12 @@
+[config]
+command = record
+args    = --no-bpf-event -e cycles/period=3,alt-period=2/ -- kill >/dev/null 2>&1
+ret     = 1
+kernel_since = 6.11
+
+[event-10:base-record]
+sample_period=3
+alt_sample_period=2
+
+freq=0
+sample_type=7
tools/perf/tests/shell/attr/test-record-dummy-C0 +2 -1
index 91499405fff4..e6315918a95e 100644
@@ -10,7 +10,7 @@ cpu=0
 pid=-1
 flags=8
 type=1
-size=136
+size=144
 config=9
 sample_period=4000
 # PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME |
@@ -53,3 +53,4 @@ config2=0
 branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
+alt_sample_period=0
tools/perf/tests/shell/lib/attr.py +1 -0
index 3db9a7d78715..04e95f76005a 100644
@@ -91,6 +91,7 @@ class Event(dict):
         'branch_sample_type',
         'sample_regs_user',
         'sample_stack_user',
+        'alt_sample_period',
     ]
 
     def add(self, data):
tools/perf/util/evsel.c +1 -0
index 4a0ef095db92..0657e580ea13 100644
@@ -180,6 +180,7 @@ static int store_event(struct perf_event_attr *attr, pid_t pid, struct perf_cpu
 	WRITE_ASS(branch_sample_type, "llu");
 	WRITE_ASS(sample_regs_user,   "llu");
 	WRITE_ASS(sample_stack_user,  PRIu32);
+	WRITE_ASS(alt_sample_period,  "llu");
 
 	fclose(file);
 	return 0;
tools/perf/util/parse-events.c +15 -0
index 35e48fe56dfa..653d84080bc7 100644
@@ -805,6 +805,7 @@ const char *parse_events__term_type_str(enum parse_events__term_type term_type)
 		[PARSE_EVENTS__TERM_TYPE_RAW]                   = "raw",
 		[PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE]          = "legacy-cache",
 		[PARSE_EVENTS__TERM_TYPE_HARDWARE]              = "hardware",
+		[PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD]	= "alt-period",
 	};
 	if ((unsigned int)term_type >= __PARSE_EVENTS__TERM_TYPE_NR)
 		return "unknown term";
@@ -833,6 +834,7 @@ config_term_avail(enum parse_events__term_type term_type, struct parse_events_er
 	case PARSE_EVENTS__TERM_TYPE_NAME:
 	case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
 	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
+	case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
 	case PARSE_EVENTS__TERM_TYPE_PERCORE:
 		return true;
 	case PARSE_EVENTS__TERM_TYPE_USER:
@@ -981,6 +983,16 @@ do {									   \
 			return -EINVAL;
 		}
 		break;
+	case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
+		CHECK_TYPE_VAL(NUM);
+		if (term->val.num == 0) {
+			parse_events_error__handle(err, term->err_val,
+						strdup("expected a non-zero value"),
+						NULL);
+			return -EINVAL;
+		}
+		attr->alt_sample_period = term->val.num;
+		break;
 	case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
 	case PARSE_EVENTS__TERM_TYPE_USER:
 	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
@@ -1108,6 +1120,7 @@ static int config_term_tracepoint(struct perf_event_attr *attr,
 	case PARSE_EVENTS__TERM_TYPE_RAW:
 	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 	case PARSE_EVENTS__TERM_TYPE_HARDWARE:
+	case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
 	default:
 		if (err) {
 			parse_events_error__handle(err, term->err_term,
@@ -1242,6 +1255,7 @@ do {								\
 		case PARSE_EVENTS__TERM_TYPE_RAW:
 		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
+		case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
 		default:
 			break;
 		}
@@ -1296,6 +1310,7 @@ static int get_config_chgs(struct perf_pmu *pmu, struct parse_events_terms *head
 		case PARSE_EVENTS__TERM_TYPE_RAW:
 		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
+		case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
 		default:
 			break;
 		}
tools/perf/util/parse-events.h +2 -1
index e176a34ab088..d00bb6c5d9ab 100644
@@ -80,7 +80,8 @@ enum parse_events__term_type {
 	PARSE_EVENTS__TERM_TYPE_RAW,
 	PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE,
 	PARSE_EVENTS__TERM_TYPE_HARDWARE,
-#define	__PARSE_EVENTS__TERM_TYPE_NR (PARSE_EVENTS__TERM_TYPE_HARDWARE + 1)
+	PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD,
+#define	__PARSE_EVENTS__TERM_TYPE_NR (PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD + 1)
 };
 
 struct parse_events_term {
tools/perf/util/parse-events.l +1 -0
index 7ed86e3e34e3..9c64434167b7 100644
@@ -335,6 +335,7 @@ aux-output		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT); }
 aux-action		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_ACTION); }
 aux-sample-size		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE); }
 metric-id		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_METRIC_ID); }
+alt-period		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD); }
 cpu-cycles|cycles				{ return hw_term(yyscanner, PERF_COUNT_HW_CPU_CYCLES); }
 stalled-cycles-frontend|idle-cycles-frontend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
 stalled-cycles-backend|idle-cycles-backend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
tools/perf/util/perf_event_attr_fprintf.c +1 -0
index c7f3543b9921..e823240b7dd8 100644
@@ -334,6 +334,7 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
 	PRINT_ATTRf(aux_start_paused, p_unsigned);
 	PRINT_ATTRf(aux_pause, p_unsigned);
 	PRINT_ATTRf(aux_resume, p_unsigned);
+	PRINT_ATTRf(alt_sample_period, p_unsigned);
 
 	return ret;
 }
tools/perf/util/pmu.c +1 -0
index 57450c73fb63..7576fe35a869 100644
@@ -1804,6 +1804,7 @@ int perf_pmu__for_each_format(struct perf_pmu *pmu, void *state, pmu_format_call
 		"aux-output",
 		"aux-action=(pause|resume|start-paused)",
 		"aux-sample-size=number",
+		"alt-period=number",
 	};
 	struct perf_pmu_format *format;
 	int ret;
Signature · 1 line
2.43.0
#14 lore raw

PATCH v3 5/5 tools/perf: Modify event parser to support alt-period-jitter term

In reply to [email protected]

From: Ben Gainey <[email protected]>

parse-events is modified, adding the "alt-period-jitter" term which can be used to enable random jitter of the alternative sample period.

---
 tools/include/uapi/linux/perf_event.h             |  7 ++++++-
 tools/perf/tests/shell/attr/base-record           |  1 +
 tools/perf/tests/shell/attr/base-record-spe       |  1 +
 tools/perf/tests/shell/attr/base-stat             |  1 +
 tools/perf/tests/shell/attr/system-wide-dummy     |  1 +
 .../shell/attr/test-record-alt-period-jitter-term | 13 +++++++++++++
 tools/perf/tests/shell/attr/test-record-dummy-C0  |  1 +
 tools/perf/tests/shell/lib/attr.py                |  1 +
 tools/perf/util/evsel.c                           |  1 +
 tools/perf/util/parse-events.c                    | 15 +++++++++++++++
 tools/perf/util/parse-events.h                    |  3 ++-
 tools/perf/util/parse-events.l                    |  1 +
 tools/perf/util/pmu.c                             |  3 ++-
 13 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 tools/perf/tests/shell/attr/test-record-alt-period-jitter-term
tools/include/uapi/linux/perf_event.h +6 -1
index 499a8673df8e..c0076ce8f80a 100644
@@ -461,7 +461,12 @@ struct perf_event_attr {
 				inherit_thread :  1, /* children only inherit if cloned with CLONE_THREAD */
 				remove_on_exec :  1, /* event is removed from task on exec */
 				sigtrap        :  1, /* send synchronous SIGTRAP on event */
-				__reserved_1   : 26;
+				/*
+				 * Add a limited amount of jitter on each alternate period, where
+				 * the jitter is between [0, (2<<jitter_alt_period) - 1]
+				 */
+				jitter_alt_period : 3,
+				__reserved_1   : 23;
 
 	union {
 		__u32		wakeup_events;	  /* wakeup every n events */
tools/perf/tests/shell/attr/base-record +1 -0
index 28a7233f7bc1..1f5ab125c78d 100644
@@ -40,3 +40,4 @@ branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
 alt_sample_period=0
+jitter_alt_period=0
tools/perf/tests/shell/attr/base-record-spe +1 -0
index ad8eb72e655a..b35ca04b2ce4 100644
@@ -39,3 +39,4 @@ branch_sample_type=*
 sample_regs_user=*
 sample_stack_user=*
 alt_sample_period=0
+jitter_alt_period=0
tools/perf/tests/shell/attr/base-stat +1 -0
index 2de92c5c300d..2d90a055686a 100644
@@ -40,3 +40,4 @@ branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
 alt_sample_period=0
+jitter_alt_period=0
tools/perf/tests/shell/attr/system-wide-dummy +1 -0
index c0a17bb3c022..527707b505e0 100644
@@ -51,3 +51,4 @@ branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
 alt_sample_period=0
+jitter_alt_period=0
tools/perf/tests/shell/attr/test-record-alt-period-jitter-term new file +13 -0
new file mode 100644
index 000000000000..6b31c898c905
@@ -0,0 +1,13 @@
+[config]
+command = record
+args    = --no-bpf-event -e cycles/period=3,alt-period=2,alt-period-jitter=7/ -- kill >/dev/null 2>&1
+ret     = 1
+kernel_since = 6.11
+
+[event-10:base-record]
+sample_period=3
+alt_sample_period=2
+jitter_alt_period=7
+
+freq=0
+sample_type=7
tools/perf/tests/shell/attr/test-record-dummy-C0 +1 -0
index e6315918a95e..436534df0434 100644
@@ -54,3 +54,4 @@ branch_sample_type=0
 sample_regs_user=0
 sample_stack_user=0
 alt_sample_period=0
+jitter_alt_period=0
tools/perf/tests/shell/lib/attr.py +1 -0
index 04e95f76005a..d15363e925fe 100644
@@ -92,6 +92,7 @@ class Event(dict):
         'sample_regs_user',
         'sample_stack_user',
         'alt_sample_period',
+        'jitter_alt_period',
     ]
 
     def add(self, data):
tools/perf/util/evsel.c +1 -0
index 0657e580ea13..2bb3e346f2b9 100644
@@ -181,6 +181,7 @@ static int store_event(struct perf_event_attr *attr, pid_t pid, struct perf_cpu
 	WRITE_ASS(sample_regs_user,   "llu");
 	WRITE_ASS(sample_stack_user,  PRIu32);
 	WRITE_ASS(alt_sample_period,  "llu");
+	WRITE_ASS(jitter_alt_period,  "d");
 
 	fclose(file);
 	return 0;
tools/perf/util/parse-events.c +15 -0
index 653d84080bc7..2e0ecfb77af3 100644
@@ -806,6 +806,7 @@ const char *parse_events__term_type_str(enum parse_events__term_type term_type)
 		[PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE]          = "legacy-cache",
 		[PARSE_EVENTS__TERM_TYPE_HARDWARE]              = "hardware",
 		[PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD]	= "alt-period",
+		[PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER]	= "alt-period-jitter",
 	};
 	if ((unsigned int)term_type >= __PARSE_EVENTS__TERM_TYPE_NR)
 		return "unknown term";
@@ -835,6 +836,7 @@ config_term_avail(enum parse_events__term_type term_type, struct parse_events_er
 	case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
 	case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 	case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
+	case PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
 	case PARSE_EVENTS__TERM_TYPE_PERCORE:
 		return true;
 	case PARSE_EVENTS__TERM_TYPE_USER:
@@ -993,6 +995,16 @@ do {									   \
 		}
 		attr->alt_sample_period = term->val.num;
 		break;
+	case PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
+		CHECK_TYPE_VAL(NUM);
+		if ((unsigned int)term->val.num > 7) {
+			parse_events_error__handle(err, term->err_val,
+						strdup("expected a value between 0-7"),
+						NULL);
+			return -EINVAL;
+		}
+		attr->jitter_alt_period = (unsigned int)term->val.num;
+		break;
 	case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
 	case PARSE_EVENTS__TERM_TYPE_USER:
 	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
@@ -1121,6 +1133,7 @@ static int config_term_tracepoint(struct perf_event_attr *attr,
 	case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 	case PARSE_EVENTS__TERM_TYPE_HARDWARE:
 	case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
+	case PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
 	default:
 		if (err) {
 			parse_events_error__handle(err, term->err_term,
@@ -1256,6 +1269,7 @@ do {								\
 		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
 		case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
+		case PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
 		default:
 			break;
 		}
@@ -1311,6 +1325,7 @@ static int get_config_chgs(struct perf_pmu *pmu, struct parse_events_terms *head
 		case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE:
 		case PARSE_EVENTS__TERM_TYPE_HARDWARE:
 		case PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD:
+		case PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
 		default:
 			break;
 		}
tools/perf/util/parse-events.h +2 -1
index d00bb6c5d9ab..dafd4b4d0f0e 100644
@@ -81,7 +81,8 @@ enum parse_events__term_type {
 	PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE,
 	PARSE_EVENTS__TERM_TYPE_HARDWARE,
 	PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD,
-#define	__PARSE_EVENTS__TERM_TYPE_NR (PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD + 1)
+	PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER,
+#define	__PARSE_EVENTS__TERM_TYPE_NR (PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER + 1)
 };
 
 struct parse_events_term {
tools/perf/util/parse-events.l +1 -0
index 9c64434167b7..91d312a23769 100644
@@ -336,6 +336,7 @@ aux-action		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_ACTION); }
 aux-sample-size		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE); }
 metric-id		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_METRIC_ID); }
 alt-period		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_ALT_SAMPLE_PERIOD); }
+alt-period-jitter	{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER); }
 cpu-cycles|cycles				{ return hw_term(yyscanner, PERF_COUNT_HW_CPU_CYCLES); }
 stalled-cycles-frontend|idle-cycles-frontend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
 stalled-cycles-backend|idle-cycles-backend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
tools/perf/util/pmu.c +2 -1
index 7576fe35a869..c665dc35ad6b 100644
@@ -1429,7 +1429,7 @@ static int pmu_config_term(const struct perf_pmu *pmu,
 			break;
 		case PARSE_EVENTS__TERM_TYPE_USER: /* Not hardcoded. */
 			return -EINVAL;
-		case PARSE_EVENTS__TERM_TYPE_NAME ... PARSE_EVENTS__TERM_TYPE_HARDWARE:
+		case PARSE_EVENTS__TERM_TYPE_NAME ... PARSE_EVENTS__TERM_TYPE_ALT_PERIOD_JITTER:
 			/* Skip non-config terms. */
 			break;
 		default:
@@ -1805,6 +1805,7 @@ int perf_pmu__for_each_format(struct perf_pmu *pmu, void *state, pmu_format_call
 		"aux-action=(pause|resume|start-paused)",
 		"aux-sample-size=number",
 		"alt-period=number",
+		"alt-period-jitter=number",
 	};
 	struct perf_pmu_format *format;
 	int ret;
Signature · 1 line
2.43.0