|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] Re: [Xen-devel] [PATCH v3 4/5] xen: sched_null: support for hard affinity
On 07/04/17 13:28, Dario Faggioli wrote:
> As a (rudimental) way of directing and affecting the
> placement logic implemented by the scheduler, support
> vCPU hard affinity.
>
> Basically, a vCPU will now be assigned only to a pCPU
> that is part of its own hard affinity. If such pCPU(s)
> is (are) busy, the vCPU will wait, like it happens
> when there are no free pCPUs.
>
> Signed-off-by: Dario Faggioli <dario.faggioli@xxxxxxxxxx>
Reviewed-by: George Dunlap <george.dunlap@xxxxxxxxxx>
> ---
> Cc: George Dunlap <george.dunlap@xxxxxxxxxx>
> Cc: Stefano Stabellini <stefano@xxxxxxxxxxx>
> Cc: Julien Grall <julien.grall@xxxxxxx>
> Cc: Jonathan Davies <Jonathan.Davies@xxxxxxxxxx>
> Cc: Marcus Granado <marcus.granado@xxxxxxxxxx>
> ---
> Changes from v2:
> - when removing a vCPU from the scheduler, correctly handle the case where
> there are multiple vCPUs in the waitqueue, with different affinities.
>
> Changes from v1:
> - coding style fixes (removed some hard tabs);
> - better signature for check_nvc_affinity() (also renamed in
> vcpu_check_affinity());
> - fixed bug in null_vcpu_remove() using uninitialized cpumask.
> ---
> xen/common/sched_null.c | 71
> ++++++++++++++++++++++++++++++-----------------
> 1 file changed, 45 insertions(+), 26 deletions(-)
>
> diff --git a/xen/common/sched_null.c b/xen/common/sched_null.c
> index c2c4182..705c00a 100644
> --- a/xen/common/sched_null.c
> +++ b/xen/common/sched_null.c
> @@ -115,6 +115,14 @@ static inline struct null_dom *null_dom(const struct
> domain *d)
> return d->sched_priv;
> }
>
> +static inline bool vcpu_check_affinity(struct vcpu *v, unsigned int cpu)
> +{
> + cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
> + cpupool_domain_cpumask(v->domain));
> +
> + return cpumask_test_cpu(cpu, cpumask_scratch_cpu(cpu));
> +}
> +
> static int null_init(struct scheduler *ops)
> {
> struct null_private *prv;
> @@ -276,16 +284,22 @@ static unsigned int pick_cpu(struct null_private *prv,
> struct vcpu *v)
>
> ASSERT(spin_is_locked(per_cpu(schedule_data, cpu).schedule_lock));
>
> + cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity, cpus);
> +
> /*
> - * If our processor is free, or we are assigned to it, and it is
> - * also still valid, just go for it.
> + * If our processor is free, or we are assigned to it, and it is also
> + * still valid and part of our affinity, just go for it.
> + * (Note that we may call vcpu_check_affinity(), but we deliberately
> + * don't, so we get to keep in the scratch cpumask what we have just
> + * put in it.)
> */
> if ( likely((per_cpu(npc, cpu).vcpu == NULL || per_cpu(npc, cpu).vcpu ==
> v)
> - && cpumask_test_cpu(cpu, cpus)) )
> + && cpumask_test_cpu(cpu, cpumask_scratch_cpu(cpu))) )
> return cpu;
>
> - /* If not, just go for a valid free pCPU, if any */
> - cpumask_and(cpumask_scratch_cpu(cpu), &prv->cpus_free, cpus);
> + /* If not, just go for a free pCPU, within our affinity, if any */
> + cpumask_and(cpumask_scratch_cpu(cpu), cpumask_scratch_cpu(cpu),
> + &prv->cpus_free);
> new_cpu = cpumask_first(cpumask_scratch_cpu(cpu));
>
> if ( likely(new_cpu != nr_cpu_ids) )
> @@ -302,7 +316,8 @@ static unsigned int pick_cpu(struct null_private *prv,
> struct vcpu *v)
> * as we will actually assign the vCPU to the pCPU we return from here,
> * only if the pCPU is free.
> */
> - return cpumask_any(cpus);
> + cpumask_and(cpumask_scratch_cpu(cpu), cpus, v->cpu_hard_affinity);
> + return cpumask_any(cpumask_scratch_cpu(cpu));
> }
>
> static void vcpu_assign(struct null_private *prv, struct vcpu *v,
> @@ -361,6 +376,7 @@ static void null_vcpu_insert(const struct scheduler *ops,
> struct vcpu *v)
> {
> struct null_private *prv = null_priv(ops);
> struct null_vcpu *nvc = null_vcpu(v);
> + unsigned int cpu;
> spinlock_t *lock;
>
> ASSERT(!is_idle_vcpu(v));
> @@ -368,23 +384,25 @@ static void null_vcpu_insert(const struct scheduler
> *ops, struct vcpu *v)
> lock = vcpu_schedule_lock_irq(v);
> retry:
>
> - v->processor = pick_cpu(prv, v);
> + cpu = v->processor = pick_cpu(prv, v);
>
> spin_unlock(lock);
>
> lock = vcpu_schedule_lock(v);
>
> + cpumask_and(cpumask_scratch_cpu(cpu), v->cpu_hard_affinity,
> + cpupool_domain_cpumask(v->domain));
> +
> /* If the pCPU is free, we assign v to it */
> - if ( likely(per_cpu(npc, v->processor).vcpu == NULL) )
> + if ( likely(per_cpu(npc, cpu).vcpu == NULL) )
> {
> /*
> * Insert is followed by vcpu_wake(), so there's no need to poke
> * the pcpu with the SCHEDULE_SOFTIRQ, as wake will do that.
> */
> - vcpu_assign(prv, v, v->processor);
> + vcpu_assign(prv, v, cpu);
> }
> - else if ( cpumask_intersects(&prv->cpus_free,
> - cpupool_domain_cpumask(v->domain)) )
> + else if ( cpumask_intersects(&prv->cpus_free, cpumask_scratch_cpu(cpu)) )
> {
> /*
> * If the pCPU is not free (e.g., because we raced with another
> @@ -413,27 +431,27 @@ static void null_vcpu_insert(const struct scheduler
> *ops, struct vcpu *v)
> static void _vcpu_remove(struct null_private *prv, struct vcpu *v)
> {
> unsigned int cpu = v->processor;
> - struct domain *d = v->domain;
> struct null_vcpu *wvc;
>
> ASSERT(list_empty(&null_vcpu(v)->waitq_elem));
>
> + vcpu_deassign(prv, v, cpu);
> +
> spin_lock(&prv->waitq_lock);
>
> /*
> - * If v is assigned to a pCPU, let's see if there is someone waiting.
> - * If yes, we assign it to cpu, in spite of v.
> + * If v is assigned to a pCPU, let's see if there is someone waiting,
> + * suitable to be assigned to it.
> */
> - wvc = list_first_entry_or_null(&prv->waitq, struct null_vcpu,
> waitq_elem);
> - if ( wvc && cpumask_test_cpu(cpu, cpupool_domain_cpumask(d)) )
> + list_for_each_entry( wvc, &prv->waitq, waitq_elem )
> {
> - list_del_init(&wvc->waitq_elem);
> - vcpu_assign(prv, wvc->vcpu, cpu);
> - cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
> - }
> - else
> - {
> - vcpu_deassign(prv, v, cpu);
> + if ( vcpu_check_affinity(wvc->vcpu, cpu) )
> + {
> + list_del_init(&wvc->waitq_elem);
> + vcpu_assign(prv, wvc->vcpu, cpu);
> + cpu_raise_softirq(cpu, SCHEDULE_SOFTIRQ);
> + break;
> + }
> }
>
> spin_unlock(&prv->waitq_lock);
> @@ -547,11 +565,12 @@ static void null_vcpu_migrate(const struct scheduler
> *ops, struct vcpu *v,
> * Let's now consider new_cpu, which is where v is being sent. It can be
> * either free, or have a vCPU already assigned to it.
> *
> - * In the former case, we should assign v to it, and try to get it to
> run.
> + * In the former case, we should assign v to it, and try to get it to
> run,
> + * if possible, according to affinity.
> *
> * In latter, all we can do is to park v in the waitqueue.
> */
> - if ( per_cpu(npc, new_cpu).vcpu == NULL )
> + if ( per_cpu(npc, new_cpu).vcpu == NULL && vcpu_check_affinity(v,
> new_cpu) )
> {
> /* v might have been in the waitqueue, so remove it */
> spin_lock(&prv->waitq_lock);
> @@ -635,7 +654,7 @@ static struct task_slice null_schedule(const struct
> scheduler *ops,
> {
> spin_lock(&prv->waitq_lock);
> wvc = list_first_entry_or_null(&prv->waitq, struct null_vcpu,
> waitq_elem);
> - if ( wvc )
> + if ( wvc && vcpu_check_affinity(wvc->vcpu, cpu) )
> {
> vcpu_assign(prv, wvc->vcpu, cpu);
> list_del_init(&wvc->waitq_elem);
>
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
https://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |