From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: [PATCH v3 4/6] xen: sched: better handle (not) inserting idle vCPUs in runqueues Date: Fri, 30 Oct 2015 00:04:35 +0100 Message-ID: <20151029230435.25219.56819.stgit@Solace.station> References: <20151029225158.25219.4625.stgit@Solace.station> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1ZrwFL-0005DB-97 for xen-devel@lists.xenproject.org; Thu, 29 Oct 2015 23:04:39 +0000 Received: by wicfv8 with SMTP id fv8so55311627wic.0 for ; Thu, 29 Oct 2015 16:04:37 -0700 (PDT) In-Reply-To: <20151029225158.25219.4625.stgit@Solace.station> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org To: xen-devel@lists.xenproject.org Cc: George Dunlap , Juergen Gross List-Id: xen-devel@lists.xenproject.org Idle vCPUs are set to run immediately, as a part of their own initialization, so we shouldn't even try to put them in a runqueue. In fact, actual schedulers don't do that, even when asked to (that is rather explicit in Credit2 and RTDS, a bit less evident in Credit1). Let's make things look as follows: - in generic code, explicitly avoid even trying to insert idle vcpus in runqueues; - in specific schedulers' code, enforce that. Note that, as csched_vcpu_insert() is no longer being called, during boot, from sched_init_vcpu(), we can safely avoid saving the flags when taking the runqueue lock. Signed-off-by: Dario Faggioli Acked-by: George Dunlap Reviewed-by: Juergen Gross --- Changes from v1: * changelog: updated and made a little bit less verbose. --- xen/common/sched_credit.c | 7 ++++--- xen/common/sched_credit2.c | 25 ++++++++++--------------- xen/common/sched_rt.c | 4 +--- xen/common/schedule.c | 20 +++++++++++--------- 4 files changed, 26 insertions(+), 30 deletions(-) diff --git a/xen/common/sched_credit.c b/xen/common/sched_credit.c index e16bd3a..fc447a7 100644 --- a/xen/common/sched_credit.c +++ b/xen/common/sched_credit.c @@ -904,14 +904,15 @@ csched_vcpu_insert(const struct scheduler *ops, struct vcpu *vc) { struct csched_vcpu *svc = vc->sched_priv; spinlock_t *lock; - unsigned long flags; - lock = vcpu_schedule_lock_irqsave(vc, &flags); + BUG_ON( is_idle_vcpu(vc) ); + + lock = vcpu_schedule_lock_irq(vc); if ( !__vcpu_on_runq(svc) && vcpu_runnable(vc) && !vc->is_running ) __runq_insert(vc->processor, svc); - vcpu_schedule_unlock_irqrestore(lock, flags, vc); + vcpu_schedule_unlock_irq(lock, vc); SCHED_STAT_CRANK(vcpu_insert); } diff --git a/xen/common/sched_credit2.c b/xen/common/sched_credit2.c index fc51a75..556ca0f 100644 --- a/xen/common/sched_credit2.c +++ b/xen/common/sched_credit2.c @@ -868,30 +868,25 @@ csched2_vcpu_insert(const struct scheduler *ops, struct vcpu *vc) { struct csched2_vcpu *svc = vc->sched_priv; struct csched2_dom * const sdom = svc->sdom; + spinlock_t *lock; printk("%s: Inserting %pv\n", __func__, vc); - /* NB: On boot, idle vcpus are inserted before alloc_pdata() has - * been called for that cpu. - */ - if ( ! is_idle_vcpu(vc) ) - { - spinlock_t *lock; + BUG_ON(is_idle_vcpu(vc)); - /* FIXME: Do we need the private lock here? */ - list_add_tail(&svc->sdom_elem, &svc->sdom->vcpu); + /* FIXME: Do we need the private lock here? */ + list_add_tail(&svc->sdom_elem, &svc->sdom->vcpu); - /* Add vcpu to runqueue of initial processor */ - lock = vcpu_schedule_lock_irq(vc); + /* Add vcpu to runqueue of initial processor */ + lock = vcpu_schedule_lock_irq(vc); - runq_assign(ops, vc); + runq_assign(ops, vc); - vcpu_schedule_unlock_irq(lock, vc); + vcpu_schedule_unlock_irq(lock, vc); - sdom->nr_vcpus++; + sdom->nr_vcpus++; - SCHED_STAT_CRANK(vcpu_insert); - } + SCHED_STAT_CRANK(vcpu_insert); CSCHED2_VCPU_CHECK(vc); } diff --git a/xen/common/sched_rt.c b/xen/common/sched_rt.c index 3a66c9a..cbe7b17 100644 --- a/xen/common/sched_rt.c +++ b/xen/common/sched_rt.c @@ -624,9 +624,7 @@ rt_vcpu_insert(const struct scheduler *ops, struct vcpu *vc) s_time_t now = NOW(); spinlock_t *lock; - /* not addlocate idle vcpu to dom vcpu list */ - if ( is_idle_vcpu(vc) ) - return; + BUG_ON( is_idle_vcpu(vc) ); lock = vcpu_schedule_lock_irq(vc); if ( now >= svc->cur_deadline ) diff --git a/xen/common/schedule.c b/xen/common/schedule.c index 9f5e12b..6ad516f 100644 --- a/xen/common/schedule.c +++ b/xen/common/schedule.c @@ -240,20 +240,22 @@ int sched_init_vcpu(struct vcpu *v, unsigned int processor) init_timer(&v->poll_timer, poll_timer_fn, v, v->processor); - /* Idle VCPUs are scheduled immediately. */ + v->sched_priv = SCHED_OP(DOM2OP(d), alloc_vdata, v, d->sched_priv); + if ( v->sched_priv == NULL ) + return 1; + + TRACE_2D(TRC_SCHED_DOM_ADD, v->domain->domain_id, v->vcpu_id); + + /* Idle VCPUs are scheduled immediately, so don't put them in runqueue. */ if ( is_idle_domain(d) ) { per_cpu(schedule_data, v->processor).curr = v; v->is_running = 1; } - - TRACE_2D(TRC_SCHED_DOM_ADD, v->domain->domain_id, v->vcpu_id); - - v->sched_priv = SCHED_OP(DOM2OP(d), alloc_vdata, v, d->sched_priv); - if ( v->sched_priv == NULL ) - return 1; - - SCHED_OP(DOM2OP(d), insert_vcpu, v); + else + { + SCHED_OP(DOM2OP(d), insert_vcpu, v); + } return 0; }