From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752283AbbDZRM5 (ORCPT ); Sun, 26 Apr 2015 13:12:57 -0400 Received: from m15-114.126.com ([220.181.15.114]:56524 "EHLO m15-114.126.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750937AbbDZRMu (ORCPT ); Sun, 26 Apr 2015 13:12:50 -0400 From: Xunlei Pang To: linux-kernel@vger.kernel.org Cc: Peter Zijlstra , Steven Rostedt , Juri Lelli , Ingo Molnar , Xunlei Pang Subject: [RFC PATCH 1/6] sched/rt: Provide new check_preempt_equal_prio_common() Date: Mon, 27 Apr 2015 01:10:53 +0800 Message-Id: <1430068258-1960-1-git-send-email-xlpang@126.com> X-Mailer: git-send-email 2.1.0 X-CM-TRANSID: DsmowACX+G4iHD1V8BojAA--.830S2 X-Coremail-Antispam: 1Uf129KBjvJXoWxZFWxGw4rur48Cry3Aw45GFg_yoWrJF1Dpa 1ku34rZw4DJ3WIgw1fAr4kZw4fKwnYyw45Krn3t3yFkF45tr4F93W5JF17tryrZr18WF1a qr4DtFW7Ca1qvFJanT9S1TB71UUUUUUqnTZGkaVYY2UrUUUUjbIjqfuFe4nvWSU5nxnvy2 9KBjDUYxBIdaVFxhVjvjDU0xZFpf9x07jSWlkUUUUU= X-Originating-IP: [220.166.221.63] X-CM-SenderInfo: p0ost0bj6rjloofrz/1tbipBHnv1GogZ1G4AAAsu Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Xunlei Pang When p is queued, there may be other tasks already queued at the same priority in the "run queue", so we should peek the most front one to do the equal priority preemption. This patch modifies check_preempt_equal_prio() and provides new check_preempt_equal_prio_common() to do the common preemption. There are also other cases to be added calling the new interface in the following patches. Signed-off-by: Xunlei Pang --- kernel/sched/rt.c | 70 ++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 54 insertions(+), 16 deletions(-) diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c index 575da76..6b40555 100644 --- a/kernel/sched/rt.c +++ b/kernel/sched/rt.c @@ -1366,33 +1366,66 @@ out: return cpu; } -static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p) +static struct task_struct *peek_next_task_rt(struct rq *rq); + +static void check_preempt_equal_prio_common(struct rq *rq) { + struct task_struct *curr = rq->curr; + struct task_struct *next; + + /* Current can't be migrated, useless to reschedule */ + if (curr->nr_cpus_allowed == 1 || + !cpupri_find(&rq->rd->cpupri, curr, NULL)) + return; + /* - * Current can't be migrated, useless to reschedule, - * let's hope p can move out. + * Can we find any task with the same priority as + * curr? To accomplish this, firstly requeue curr + * to the tail, then peek next, finally put curr + * back to the head if a different task was peeked. */ - if (rq->curr->nr_cpus_allowed == 1 || - !cpupri_find(&rq->rd->cpupri, rq->curr, NULL)) + requeue_task_rt(rq, curr, 0); + next = peek_next_task_rt(rq); + if (next == curr) + return; + + requeue_task_rt(rq, curr, 1); + + if (next->prio != curr->prio) return; /* - * p is migratable, so let's not schedule it and - * see if it is pushed or pulled somewhere else. + * Got the right next queued with the same priority + * as current. If next is migratable, don't schedule + * it as it will be pushed or pulled somewhere else. */ - if (p->nr_cpus_allowed != 1 - && cpupri_find(&rq->rd->cpupri, p, NULL)) + if (next->nr_cpus_allowed != 1 && + cpupri_find(&rq->rd->cpupri, next, NULL)) return; /* * There appears to be other cpus that can accept - * current and none to run 'p', so lets reschedule - * to try and push current away: + * current and none to run next, so lets reschedule + * to try and push current away. */ - requeue_task_rt(rq, p, 1); + requeue_task_rt(rq, next, 1); resched_curr(rq); } +static inline +void check_preempt_equal_prio(struct rq *rq, struct task_struct *p) +{ + /* + * p is migratable, so let's not schedule it and + * see if it is pushed or pulled somewhere else. + */ + if (p->nr_cpus_allowed != 1 && + cpupri_find(&rq->rd->cpupri, p, NULL)) + return; + + check_preempt_equal_prio_common(rq); +} + #endif /* CONFIG_SMP */ /* @@ -1440,10 +1473,9 @@ static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq, return next; } -static struct task_struct *_pick_next_task_rt(struct rq *rq) +static struct task_struct *peek_next_task_rt(struct rq *rq) { struct sched_rt_entity *rt_se; - struct task_struct *p; struct rt_rq *rt_rq = &rq->rt; do { @@ -1452,9 +1484,15 @@ static struct task_struct *_pick_next_task_rt(struct rq *rq) rt_rq = group_rt_rq(rt_se); } while (rt_rq); - p = rt_task_of(rt_se); - p->se.exec_start = rq_clock_task(rq); + return rt_task_of(rt_se); +} +static inline struct task_struct *_pick_next_task_rt(struct rq *rq) +{ + struct task_struct *p; + + p = peek_next_task_rt(rq); + p->se.exec_start = rq_clock_task(rq); return p; } -- 1.9.1