perf event scheduling updates
Ingo,
Please pull the perf/scheduling branch that can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/frederic/random-tracing.git
perf/scheduling
Thanks,
Frederic
---
Frederic Weisbecker (4):
perf/core: Split context's event group list into pinned and non-pinned lists
list: Introduce list_rotate_left()
perf: Round robin flexible groups of events using list_rotate_left()
perf: Export software-only event group characteristic as a flag
include/linux/list.h | 14 +++ include/linux/perf_event.h | 8 +- kernel/perf_event.c | 262 +++++++++++++++++++++++++++----------------- 3 files changed, 181 insertions(+), 103 deletions(-)
PATCH 1/4 perf/core: Split context's event group list into pinned and non-pinned lists
Split-up struct perf_event_context::group_list into pinned_groups and flexible_groups (non-pinned).
This first appears to be useless as it duplicates various loops around the group list handlings.
But it scales better in the fast-path in perf_sched_in(). We don't anymore iterate twice through the entire list to separate pinned and non-pinned scheduling. Instead we interate through two distinct lists.
The another desired effect is that it makes easier to define distinct scheduling rules on both.
Changes in v2:
- Respectively rename pinned_grp_list and volatile_grp_list into pinned_groups and flexible_groups as per Ingo suggestion.
- Various cleanups
--- include/linux/perf_event.h | 3 +- kernel/perf_event.c | 227 +++++++++++++++++++++++++++++--------------- 2 files changed, 153 insertions(+), 77 deletions(-)
include/linux/perf_event.h +2 -1
@@ -683,7 +683,8 @@ struct perf_event_context {*/ struct mutex mutex; -struct list_head group_list; +struct list_head pinned_groups; +struct list_head flexible_groups;struct list_head event_list;int nr_events;int nr_active;
kernel/perf_event.c +151 -76
350 lines not on this page · raw message
Signature · 1 line
1.6.2.3
PATCH 2/4 list: Introduce list_rotate_left()
In reply to Frederic WeisbeckerBring a new list_rotate_left() helper that rotates a list to the left. This is useful for codes that need to round roubin elements which queue priority increases from tail to head.
--- include/linux/list.h | 14 ++++++++++++++ 1 files changed, 14 insertions(+), 0 deletions(-)
include/linux/list.h +14 -0
@@ -206,6 +206,20 @@ static inline int list_empty_careful(const struct list_head *head) }/** +* list_rotate_left - rotate the list to the left +* @head: the head of the list +*/ +static inline void list_rotate_left (struct list_head *head) +{ +struct list_head *first; + +if (!list_empty (head)) { + first = head->next; +list_move_tail (first, head); + } +} + +/** * list_is_singular - tests whether a list has just one entry. * @head: the list to test. */
Signature · 1 line
1.6.2.3
PATCH 3/4 perf: Round robin flexible groups of events using list_rotate_left()
In reply to Frederic WeisbeckerThis is more proper that doing it through a list_for_each_entry() that breaks after the first entry.
v2: Don't rotate pinned groups as its not needed to time share them.
--- kernel/perf_event.c | 17 ++++------------- 1 files changed, 4 insertions(+), 13 deletions(-)
kernel/perf_event.c +4 -13
@@ -1454,25 +1454,16 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx)*/ static void rotate_ctx (struct perf_event_context *ctx) { -struct perf_event *event; -if (!ctx->nr_events)return ;raw_spin_lock (&ctx->lock); -/* -* Rotate the first entry last (works just fine for group events too): -*/ + +/* Rotate the first entry last of non-pinned groups */ perf_disable (); -list_for_each_entry (event, &ctx->pinned_groups, group_entry) { -list_move_tail (&event->group_entry, &ctx->pinned_groups); -break ; - } -list_for_each_entry (event, &ctx->flexible_groups, group_entry) { -list_move_tail (&event->group_entry, &ctx->flexible_groups); -break ; - } +list_rotate_left (&ctx->flexible_groups); +perf_enable ();raw_spin_unlock (&ctx->lock);
Signature · 1 line
1.6.2.3
PATCH 4/4 perf: Export software-only event group characteristic as a flag
In reply to Frederic WeisbeckerBefore scheduling an event group, we first check if a group can go on. We first check if the group is made of software only events first, in which case it is enough to know if the group can be scheduled in.
For that purpose, we iterate through the whole group, which is wasteful as we could do this check when we add/delete an event to a group.
So we create a group_flags field in perf event that can host characteristics from a group of events, starting with a first PERF_GROUP_SOFTWARE flag that reduces the check on the fast path.
--- include/linux/perf_event.h | 5 +++++ kernel/perf_event.c | 30 +++++++++++------------------- 2 files changed, 16 insertions(+), 19 deletions(-)
include/linux/perf_event.h +5 -0
@@ -565,6 +565,10 @@ typedef void (*perf_overflow_handler_t)(struct perf_event *, int, struct perf_sample_data *, struct pt_regs *regs); +enum perf_group_flag { +PERF_GROUP_SOFTWARE =0x1 , +}; +/** * struct perf_event - performance event kernel representation: */
@@ -574,6 +578,7 @@ struct perf_event {struct list_head event_entry;struct list_head sibling_list;int nr_siblings; +int group_flags;struct perf_event *group_leader;struct perf_event *output;const struct pmu *pmu;
kernel/perf_event.c +11 -19
@@ -315,9 +315,16 @@ list_add_event(struct perf_event *event, struct perf_event_context *ctx)if (group_leader == event) {struct list_head *list; +if (is_software_event (event)) + event->group_flags |=PERF_GROUP_SOFTWARE ; + list =ctx_group_list (event, ctx);list_add_tail (&event->group_entry, list); }else { +if (group_leader->group_flags &PERF_GROUP_SOFTWARE && + !is_software_event (event)) + group_leader->group_flags &= ~PERF_GROUP_SOFTWARE ; +list_add_tail (&event->group_entry, &group_leader->sibling_list); group_leader->nr_siblings++; }
@@ -372,6 +379,9 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx) list =ctx_group_list (event, ctx);list_move_tail (&sibling->group_entry, list); sibling->group_leader = sibling; + +/* Inherit group flags from the previous leader */ + sibling->group_flags = event->group_flags; } }
@@ -700,24 +710,6 @@ group_error: }/* -* Return 1 for a group consisting entirely of software events, -* 0 if the group contains any hardware events. -*/ -static int is_software_only_group (struct perf_event *leader) -{ -struct perf_event *event; - -if (!is_software_event (leader)) -return 0 ; - -list_for_each_entry (event, &leader->sibling_list, group_entry) -if (!is_software_event (event)) -return 0 ; - -return 1 ; -} - -/* * Work out whether we can put this event group on the CPU now. */ static int group_can_go_on(struct perf_event *event,
@@ -727,7 +719,7 @@ static int group_can_go_on(struct perf_event *event,/* * Groups consisting entirely of software events can always go on. */ -if (is_software_only_group (event)) +if (event->group_flags &PERF_GROUP_SOFTWARE )return 1 ;/* * If an exclusive group is already on, no other hardware
Signature · 1 line
1.6.2.3
Quoted 18 lines · Frederic Weisbecker
Ingo,
Please pull the perf/scheduling branch that can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/frederic/random-tracing.git
perf/schedulingThanks,
Frederic
---Frederic Weisbecker (4):
perf/core: Split context's event group list into pinned and non-pinned lists
list: Introducelist_rotate_left()
perf: Round robin flexible groups of events usinglist_rotate_left()
perf: Export software-only event group characteristic as a flag
Quoted 4 lines
include/linux/list.h | 14 +++ include/linux/perf_event.h | 8 +- kernel/perf_event.c | 262 +++++++++++++++++++++++++++----------------- 3 files changed, 181 insertions(+), 103 deletions(-)
Pulled, thanks a lot Frederic!
Ingo