Skip to contentSkip to conversation

perf: Implement read_group() PMU operation

RFC PATCH In review Sukadev Bhattiprolu 3 participants 5 messages Feb 6, 2015 – Feb 22, 2015

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 perf: Implement read_group() PMU operation

From: Sukadev Bhattiprolu <[email protected]>
Date: Thu Feb 5 20:56:20 EST 2015 -0300
Subject: [RFC][PATCH] perf: Implement read_group() PMU operation

This is a lightly tested, exploratory patch to allow PMUs to return several counters at once. Appreciate any comments :-)

Unlike normal hardware PMCs, the 24x7 counters[1] in Power8 are stored in memory and accessed via a hypervisor call (HCALL). A major aspect of the HCALL is that it allows retireving _SEVERAL_ counters at once (unlike regular PMCs, which are read one at a time).

This patch implements a ->read_group() PMU operation that tries to take advantage of this ability to read several counters at once. A PMU that implements the ->read_group() operation would allow users to retrieve several counters at once and get a more consistent snapshot.

NOTE: This patch has a TODO in h_24x7_event_read_group() in that it

	still does multiple HCALLS. I think that can be optimized 
	independently, once the pmu->read_group() interface itself is
	finalized.

Appreciate comments on the ->read_group interface and best managing the interfaces between the core and PMU layers - eg: Ok for hv-24x7 PMU to to walk the ->sibling_list ?

[1] Some notes about 24x7 counters:

Power8 supports 24x7 counters[1] which differ from traditional PMCs in several ways:

- The 24x7 counters are always on and counting. Rather than start/stop the PMCs, we read/report the _change_ in values in the counters during the execution of the workload.

- The 24x7 counters are not tied to a task context (they are always on).

- Rather than reading the event counts from registers, we make a hypervisor call (HCALL) to retrieve counts. The HCALL allows retrieving a large number of counters in a single call.

- These counters don't generate interrupts when they overflow (so sampling does not apply to these counters).
---

include/linux/perf_event.h +7 -0
index 1d36314..b69fbdf 100644
@@ -232,6 +232,13 @@ struct pmu {
 	void (*read)			(struct perf_event *event);
 
 	/*
+	 * Read a group of counters.
+	 */
+	int (*read_group)		(struct perf_event *event,
+						u64 *values,
+						int ncounters);
+
+	/*
 	 * Group events scheduling is treated as a transaction, add
 	 * group events as a whole and perform one schedulability test.
 	 * If the test fails, roll back the whole group
kernel/events/core.c +33 -0
index 934687f..026a9d0 100644
@@ -3549,10 +3549,43 @@ static int perf_event_read_group(struct perf_event *event,
 	struct perf_event *leader = event->group_leader, *sub;
 	int n = 0, size = 0, ret = -EFAULT;
 	struct perf_event_context *ctx = leader->ctx;
+	u64 *valuesp;
 	u64 values[5];
+	int use_group_read;
 	u64 count, enabled, running;
+	struct pmu *pmu = event->pmu;
+
+	/*
+	 * If PMU supports group read and group read is requested,
+	 * allocate memory before taking the mutex.
+	 */
+	use_group_read = 0;
+	if ((read_format & PERF_FORMAT_GROUP) && pmu->read_group) {
+		use_group_read++;
+	}
+
+	if (use_group_read) {
+		valuesp = kzalloc(leader->nr_siblings * sizeof(u64), GFP_KERNEL);
+		if (!valuesp)
+			return -ENOMEM;
+	}
 
 	mutex_lock(&ctx->mutex);
+
+	if (use_group_read) {
+		ret = pmu->read_group(leader, valuesp, leader->nr_siblings);
+		if (ret >= 0) {
+			size = ret * sizeof(u64);
+
+			ret = size;
+			if (copy_to_user(buf, valuesp, size))
+				ret = -EFAULT;
+		}
+
+		kfree(valuesp);
+		goto unlock;
+	}
+
 	count = perf_event_read_value(leader, &enabled, &running);
 
 	values[n++] = 1 + leader->nr_siblings;
arch/powerpc/perf/hv-24x7.c +66 -0

90 lines not on this page · raw message

maintainer
#1 lore raw

kernel/events/core.c static int perf_event_read_group(struct perf_event *event,

Quoted 31 lines · Sukadev Bhattiprolu

From: Sukadev Bhattiprolu <[email protected]>
Date: Thu Feb 5 20:56:20 EST 2015 -0300
Subject: [RFC][PATCH] perf: Implement read_group() PMU operation

This is a lightly tested, exploratory patch to allow PMUs to return several counters at once. Appreciate any comments :-)

Unlike normal hardware PMCs, the 24x7 counters[1] in Power8 are stored in memory and accessed via a hypervisor call (HCALL). A major aspect of the HCALL is that it allows retireving _SEVERAL_ counters at once (unlike regular PMCs, which are read one at a time).

This patch implements a ->read_group() PMU operation that tries to take advantage of this ability to read several counters at once. A PMU that implements the ->read_group() operation would allow users to retrieve several counters at once and get a more consistent snapshot.

NOTE: This patch has a TODO in h_24x7_event_read_group() in that it

	still does multiple HCALLS. I think that can be optimized 
	independently, once the pmu->read_group() interface itself is
	finalized.

Appreciate comments on the ->read_group interface and best managing the interfaces between the core and PMU layers - eg: Ok for hv-24x7 PMU to to walk the ->sibling_list ?

kernel/events/core.c +0 -0
@@ -3549,10 +3549,43 @@ static int perf_event_read_group(struct perf_event *event,

You also want perf_output_read_group().

Quoted 13 lines
kernel/events/core.c +8 -0
 	struct perf_event *leader = event->group_leader, *sub;
 	int n = 0, size = 0, ret = -EFAULT;
 	struct perf_event_context *ctx = leader->ctx;
+	u64 *valuesp;
 	u64 values[5];
+	int use_group_read;
 	u64 count, enabled, running;
+	struct pmu *pmu = event->pmu;
+
+	/*
+	 * If PMU supports group read and group read is requested,
+	 * allocate memory before taking the mutex.
+	 */

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

Quoted 10 lines
kernel/events/core.c +10 -0
+	use_group_read = 0;
+	if ((read_format & PERF_FORMAT_GROUP) && pmu->read_group) {
+		use_group_read++;
+	}
+
+	if (use_group_read) {
+		valuesp = kzalloc(leader->nr_siblings * sizeof(u64), GFP_KERNEL);
+		if (!valuesp)
+			return -ENOMEM;
+	}

This seems 'sad', the hardware already knows how many it can maximally use at once and can preallocate, right?

Quoted 10 lines
kernel/events/core.c +8 -0
 	mutex_lock(&ctx->mutex);
+
+	if (use_group_read) {
+		ret = pmu->read_group(leader, valuesp, leader->nr_siblings);
+		if (ret >= 0) {
+			size = ret * sizeof(u64);
+
+			ret = size;
+			if (copy_to_user(buf, valuesp, size))

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

Quoted 10 lines
kernel/events/core.c +7 -0
+				ret = -EFAULT;
+		}
+
+		kfree(valuesp);
+		goto unlock;
+	}
+
 	count = perf_event_read_value(leader, &enabled, &running);
 
 	values[n++] = 1 + leader->nr_siblings;

Since ->read() has a void return value, we can delay its effect, so I'm currently thinking we might want to extend the transaction interface for this; give pmu::start_txn() a flags argument to indicate scheduling (add) or reading (read).

So we'd end up with something like:

	pmu->start_txn(pmu, PMU_TXN_READ);

	leader->read();

	for_each_sibling()
		sibling->read();

	pmu->commit_txn();

after which we can use the values updated by the read calls. The trivial no-support implementation lets read do its immediate thing like it does now.

A more complex driver can then collect the actual counter values and execute one hypercall using its pre-allocated memory.

So no allocations in the core code, and no sibling iterations in the driver code.

Would that work for you?

#2 lore raw

Peter Zijlstra [[email protected]] wrote:

| > --- a/kernel/events/core.c
| > +++ b/kernel/events/core.c
| > @@ -3549,10 +3549,43 @@ static int perf_event_read_group(struct perf_event *event,
| 
| You also want perf_output_read_group().

Ok. Will look into it. We currently don't support sampling with the 24x7 counters but we should make sure that the new interface fits correctly.

| 
| >  	struct perf_event *leader = event->group_leader, *sub;
| >  	int n = 0, size = 0, ret = -EFAULT;
| >  	struct perf_event_context *ctx = leader->ctx;
| > +	u64 *valuesp;
| >  	u64 values[5];
| > +	int use_group_read;
| >  	u64 count, enabled, running;
| > +	struct pmu *pmu = event->pmu;
| > +
| > +	/*
| > +	 * If PMU supports group read and group read is requested,
| > +	 * allocate memory before taking the mutex.
| > +	 */
| > +	use_group_read = 0;
| > +	if ((read_format & PERF_FORMAT_GROUP) && pmu->read_group) {
| > +		use_group_read++;
| > +	}
| > +
| > +	if (use_group_read) {
| > +		valuesp = kzalloc(leader->nr_siblings * sizeof(u64), GFP_KERNEL);
| > +		if (!valuesp)
| > +			return -ENOMEM;
| > +	}
| 
| This seems 'sad', the hardware already knows how many it can maximally
| use at once and can preallocate, right?

Yeah :-) In a subsequent version, I got rid of the allocation by moving the copy_to_user() into the PMU, but still needed to walk the sibling list.

| 
| >  
| >  	mutex_lock(&ctx->mutex);
| > +
| > +	if (use_group_read) {
| > +		ret = pmu->read_group(leader, valuesp, leader->nr_siblings);
| > +		if (ret >= 0) {
| > +			size = ret * sizeof(u64);
| > +
| > +			ret = size;
| > +			if (copy_to_user(buf, valuesp, size))
| > +				ret = -EFAULT;
| > +		}
| > +
| > +		kfree(valuesp);
| > +		goto unlock;
| > +	}
| > +
| >  	count = perf_event_read_value(leader, &enabled, &running);
| >  
| >  	values[n++] = 1 + leader->nr_siblings;
| 
| Since ->read() has a void return value, we can delay its effect, so I'm
| currently thinking we might want to extend the transaction interface for
| this; give pmu::start_txn() a flags argument to indicate scheduling
| (add) or reading (read).
| 
| So we'd end up with something like:
| 
| 	pmu->start_txn(pmu, PMU_TXN_READ);
| 
| 	leader->read();
| 
| 	for_each_sibling()
| 		sibling->read();
| 
| 	pmu->commit_txn();

So, each of the ->read() calls is really "appending a counter" to a list of counters that the PMU should read and the values for the counters (results of the read) are only available after the commit_txn() right?

In which case, perf_event_read_group() would then follow this commit_txn() with its "normal" read, and the PMU would return the result cached during ->commit_txn(). If so, we need a way to invalidate the cached result ?

| 
| after which we can use the values updated by the read calls. The trivial
| no-support implementation lets read do its immediate thing like it does
| now.
| 
| A more complex driver can then collect the actual counter values and
| execute one hypercall using its pre-allocated memory.

the hypercall should happen in the ->commit_txn() right ?

| 
| So no allocations in the core code, and no sibling iterations in the
| driver code.
| 
| Would that work for you?

I think it would,

I am working on breaking up the underlying code along start/read/commit lines, and hope to have it done later this week and then can experiment more with this interface.

Appreciate the input.

Sukadev

maintainer
#3 lore raw
Quoted 10 lines · Sukadev Bhattiprolu

Peter Zijlstra [[email protected]] wrote:

| > --- a/kernel/events/core.c
| > +++ b/kernel/events/core.c
| > @@ -3549,10 +3549,43 @@ static int perf_event_read_group(struct perf_event *event,
| 
| You also want perf_output_read_group().

Ok. Will look into it. We currently don't support sampling with the 24x7 counters but we should make sure that the new interface fits correctly.

One thing someone 'could' do is group them together with a software event that _can_ sample, and then use SAMPLE_READ to periodically stuff values into the buffer.

Quoted 16 lines
| Since ->read() has a void return value, we can delay its effect, so I'm
| currently thinking we might want to extend the transaction interface for
| this; give pmu::start_txn() a flags argument to indicate scheduling
| (add) or reading (read).
| 
| So we'd end up with something like:
| 
| 	pmu->start_txn(pmu, PMU_TXN_READ);
| 
| 	leader->read();
| 
| 	for_each_sibling()
| 		sibling->read();
| 
| 	pmu->commit_txn();
Quoted 3 lines

So, each of the ->read() calls is really "appending a counter" to a list of counters that the PMU should read and the values for the counters (results of the read) are only available after the commit_txn() right?

Correct.

Quoted 3 lines

In which case, perf_event_read_group() would then follow this commit_txn() with its "normal" read, and the PMU would return the result cached during ->commit_txn(). If so, we need a way to invalidate the cached result ?

I was thinking of breaking up that code into two loops, once to call ->read() and update states, the second to use the now up-to-date data and frob it into the stream.

But I must say I've not entirely given it much thought. But that way you're not stuck with this cache and related problems.

Quoted 8 lines
| after which we can use the values updated by the read calls. The trivial
| no-support implementation lets read do its immediate thing like it does
| now.
| 
| A more complex driver can then collect the actual counter values and
| execute one hypercall using its pre-allocated memory.

the hypercall should happen in the ->commit_txn() right ?

Yah. Of course, if a ->read() is not part of a txn then it must do the hypercall for just the one value.

#4 lore raw
In reply to Sukadev Bhattiprolu
Quoted 7 lines · Sukadev Bhattiprolu

From: Sukadev Bhattiprolu <[email protected]>
Date: Thu Feb 5 20:56:20 EST 2015 -0300
Subject: [RFC][PATCH] perf: Implement read_group() PMU operation

This is a lightly tested, exploratory patch to allow PMUs to return several counters at once. Appreciate any comments :-)

Back when I was fiddling with this, I started looking into changing the {start,commit,cancel}_txn to operate on (struct perf_event *) rather than (struct pmu *), and commit_txn would generate the actual request & reads based on the perf_event's group (sounds similar but not identical to what Peter's proposed previously).

The key bit I was concerned about was that these "PMUs" aren't actually physical hw, so it made a bit more sense to pin the grouping to a group rather than a txn over a PMU.

[Of course, I never did confirm if that actually fit with how perf was modeling txns]