[PATCH v2 0/3] -tip cleanups/fixes for x2apic cluster mode routing

[PATCH v2 0/3] -tip cleanups/fixes for x2apic cluster mode routing

[Suresh Siddha]

Following patches will reserve the vector only on the cpu's where
the interrupt will be routed to based on the specified affinity mask
(not on the complete x2apic cluster which is the current behavior).
And by default during boot, device bringup etc, only one cpu
is used for interrupt destination. All this will reduce the vector
pressure (specifically for the case of single/two socket systems where
there will be atmost one or two x2apic clusters per-socket) when
there are more interrupt sources than the number of x2apic clusters.

Changes from the previous version:

* cleaned up the apic driver's vector_allocation_domain() API.
* Minimize the vector usage during boot/device bringup.

Suresh Siddha (3):
  x86, apic: optimize cpu traversal in __assign_irq_vector() using
    domain membership
  x86, x2apic: limit the vector reservation to the user specified mask
  x86, x2apic: use multiple cluster members for the irq destination
    only with the explicit affinity

 arch/x86/include/asm/apic.h           |   15 ++++++-----
 arch/x86/kernel/apic/apic_noop.c      |    4 +-
 arch/x86/kernel/apic/io_apic.c        |   44 ++++++++++++++++----------------
 arch/x86/kernel/apic/x2apic_cluster.c |   26 +++++++++++++++---
 4 files changed, 53 insertions(+), 36 deletions(-)

-- 
1.7.6.5

[PATCH v2 1/3] x86, apic: optimize cpu traversal in __assign_irq_vector() using domain membership

[Suresh Siddha]

Currently __assign_irq_vector() goes through each cpu in the specified mask
until it finds a free vector in all the cpu's that are part of the same
interrupt domain. We visit all the interrupt domain sibling cpus to reserve
the free vector. So, when we fail to find a free vector in an interrupt
domain, it is safe to continue our search with a cpu belonging to a new
interrupt domain. No need to go through each cpu, if the domain
containing that cpu is already visited.

Use the irq_cfg's old_domain to track the visited domains and optimize
the cpu traversal while finding a free vector in the given cpumask.

NOTE: We can also optimize the search by using for_each_cpu and skip the
current cpu, if it is not the first cpu in the mask returned by the
vector_allocation_domain(). But re-using the cfg->old_domain to track
the visited domains will be slightly faster.

Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Acked-by: Yinghai Lu <yinghai@kernel.org>
---
 arch/x86/include/asm/apic.h           |    8 +++-----
 arch/x86/kernel/apic/apic_noop.c      |    3 +--
 arch/x86/kernel/apic/io_apic.c        |   15 ++++++++-------
 arch/x86/kernel/apic/x2apic_cluster.c |    3 +--
 4 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
index 8619a87..b37fa12 100644
--- a/arch/x86/include/asm/apic.h
+++ b/arch/x86/include/asm/apic.h
@@ -306,7 +306,7 @@ struct apic {
 	unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
 	unsigned long (*check_apicid_present)(int apicid);
 
-	bool (*vector_allocation_domain)(int cpu, struct cpumask *retmask);
+	void (*vector_allocation_domain)(int cpu, struct cpumask *retmask);
 	void (*init_apic_ldr)(void);
 
 	void (*ioapic_phys_id_map)(physid_mask_t *phys_map, physid_mask_t *retmap);
@@ -614,7 +614,7 @@ default_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
 			       const struct cpumask *andmask,
 			       unsigned int *apicid);
 
-static inline bool
+static inline void
 flat_vector_allocation_domain(int cpu, struct cpumask *retmask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
@@ -627,14 +627,12 @@ flat_vector_allocation_domain(int cpu, struct cpumask *retmask)
 	 */
 	cpumask_clear(retmask);
 	cpumask_bits(retmask)[0] = APIC_ALL_CPUS;
-	return false;
 }
 
-static inline bool
+static inline void
 default_vector_allocation_domain(int cpu, struct cpumask *retmask)
 {
 	cpumask_copy(retmask, cpumask_of(cpu));
-	return true;
 }
 
 static inline unsigned long default_check_apicid_used(physid_mask_t *map, int apicid)
diff --git a/arch/x86/kernel/apic/apic_noop.c b/arch/x86/kernel/apic/apic_noop.c
index 65c07fc..08c337b 100644
--- a/arch/x86/kernel/apic/apic_noop.c
+++ b/arch/x86/kernel/apic/apic_noop.c
@@ -100,12 +100,11 @@ static unsigned long noop_check_apicid_present(int bit)
 	return physid_isset(bit, phys_cpu_present_map);
 }
 
-static bool noop_vector_allocation_domain(int cpu, struct cpumask *retmask)
+static void noop_vector_allocation_domain(int cpu, struct cpumask *retmask)
 {
 	if (cpu != 0)
 		pr_warning("APIC: Vector allocated for non-BSP cpu\n");
 	cpumask_copy(retmask, cpumask_of(cpu));
-	return true;
 }
 
 static u32 noop_apic_read(u32 reg)
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
index 99a794d..7a945f8 100644
--- a/arch/x86/kernel/apic/io_apic.c
+++ b/arch/x86/kernel/apic/io_apic.c
@@ -1134,12 +1134,13 @@ __assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
 
 	/* Only try and allocate irqs on cpus that are present */
 	err = -ENOSPC;
-	for_each_cpu_and(cpu, mask, cpu_online_mask) {
+	cpumask_clear(cfg->old_domain);
+	cpu = cpumask_first_and(mask, cpu_online_mask);
+	while (cpu < nr_cpu_ids) {
 		int new_cpu;
 		int vector, offset;
-		bool more_domains;
 
-		more_domains = apic->vector_allocation_domain(cpu, tmp_mask);
+		apic->vector_allocation_domain(cpu, tmp_mask);
 
 		if (cpumask_subset(tmp_mask, cfg->domain)) {
 			free_cpumask_var(tmp_mask);
@@ -1156,10 +1157,10 @@ next:
 		}
 
 		if (unlikely(current_vector == vector)) {
-			if (more_domains)
-				continue;
-			else
-				break;
+			cpumask_or(cfg->old_domain, cfg->old_domain, tmp_mask);
+			cpumask_andnot(tmp_mask, mask, cfg->old_domain);
+			cpu = cpumask_first_and(tmp_mask, cpu_online_mask);
+			continue;
 		}
 
 		if (test_bit(vector, used_vectors))
diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
index 943d03f..b5d889b 100644
--- a/arch/x86/kernel/apic/x2apic_cluster.c
+++ b/arch/x86/kernel/apic/x2apic_cluster.c
@@ -212,11 +212,10 @@ static int x2apic_cluster_probe(void)
 /*
  * Each x2apic cluster is an allocation domain.
  */
-static bool cluster_vector_allocation_domain(int cpu, struct cpumask *retmask)
+static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask)
 {
 	cpumask_clear(retmask);
 	cpumask_copy(retmask, per_cpu(cpus_in_cluster, cpu));
-	return true;
 }
 
 static struct apic apic_x2apic_cluster = {
-- 
1.7.6.5

[PATCH v2 2/3] x86, x2apic: limit the vector reservation to the user specified mask

[Suresh Siddha]

For the x2apic cluster mode, vector for an interrupt is currently reserved on
all the cpu's that are part of the x2apic cluster. But the interrupts will
be routed only to the cluster (derived from the first cpu in the mask) members
specified in the mask. So there is no need to reserve the vector in the unused
cluster members.

Modify __assign_irq_vector() to reserve the vectors based on the user
specified irq destination mask. If the new mask is a proper subset of
the currently used mask, cleanup the vector allocation on the unused cpu
members.

Also, allow the apic driver to tune the vector domain based on the
affinity mask (which in most cases is the user-specified mask).

Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Acked-by: Yinghai Lu <yinghai@kernel.org>
---
 arch/x86/include/asm/apic.h           |    9 ++++++---
 arch/x86/kernel/apic/apic_noop.c      |    3 ++-
 arch/x86/kernel/apic/io_apic.c        |   31 +++++++++++++++----------------
 arch/x86/kernel/apic/x2apic_cluster.c |    6 +++---
 4 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
index b37fa12..c276809 100644
--- a/arch/x86/include/asm/apic.h
+++ b/arch/x86/include/asm/apic.h
@@ -306,7 +306,8 @@ struct apic {
 	unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
 	unsigned long (*check_apicid_present)(int apicid);
 
-	void (*vector_allocation_domain)(int cpu, struct cpumask *retmask);
+	void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
+					 const struct cpumask *mask);
 	void (*init_apic_ldr)(void);
 
 	void (*ioapic_phys_id_map)(physid_mask_t *phys_map, physid_mask_t *retmap);
@@ -615,7 +616,8 @@ default_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
 			       unsigned int *apicid);
 
 static inline void
-flat_vector_allocation_domain(int cpu, struct cpumask *retmask)
+flat_vector_allocation_domain(int cpu, struct cpumask *retmask,
+			      const struct cpumask *mask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
 	 * specified in the interrupt destination when using lowest
@@ -630,7 +632,8 @@ flat_vector_allocation_domain(int cpu, struct cpumask *retmask)
 }
 
 static inline void
-default_vector_allocation_domain(int cpu, struct cpumask *retmask)
+default_vector_allocation_domain(int cpu, struct cpumask *retmask,
+				 const struct cpumask *mask)
 {
 	cpumask_copy(retmask, cpumask_of(cpu));
 }
diff --git a/arch/x86/kernel/apic/apic_noop.c b/arch/x86/kernel/apic/apic_noop.c
index 08c337b..e145f28 100644
--- a/arch/x86/kernel/apic/apic_noop.c
+++ b/arch/x86/kernel/apic/apic_noop.c
@@ -100,7 +100,8 @@ static unsigned long noop_check_apicid_present(int bit)
 	return physid_isset(bit, phys_cpu_present_map);
 }
 
-static void noop_vector_allocation_domain(int cpu, struct cpumask *retmask)
+static void noop_vector_allocation_domain(int cpu, struct cpumask *retmask,
+					  const struct cpumask *mask)
 {
 	if (cpu != 0)
 		pr_warning("APIC: Vector allocated for non-BSP cpu\n");
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
index 7a945f8..406eee7 100644
--- a/arch/x86/kernel/apic/io_apic.c
+++ b/arch/x86/kernel/apic/io_apic.c
@@ -1113,7 +1113,6 @@ __assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
 	 */
 	static int current_vector = FIRST_EXTERNAL_VECTOR + VECTOR_OFFSET_START;
 	static int current_offset = VECTOR_OFFSET_START % 16;
-	unsigned int old_vector;
 	int cpu, err;
 	cpumask_var_t tmp_mask;
 
@@ -1123,28 +1122,28 @@ __assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
 	if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
 		return -ENOMEM;
 
-	old_vector = cfg->vector;
-	if (old_vector) {
-		cpumask_and(tmp_mask, mask, cpu_online_mask);
-		if (cpumask_subset(tmp_mask, cfg->domain)) {
-			free_cpumask_var(tmp_mask);
-			return 0;
-		}
-	}
-
 	/* Only try and allocate irqs on cpus that are present */
 	err = -ENOSPC;
 	cpumask_clear(cfg->old_domain);
 	cpu = cpumask_first_and(mask, cpu_online_mask);
 	while (cpu < nr_cpu_ids) {
-		int new_cpu;
-		int vector, offset;
+		int new_cpu, vector, offset;
 
-		apic->vector_allocation_domain(cpu, tmp_mask);
+		apic->vector_allocation_domain(cpu, tmp_mask, mask);
 
 		if (cpumask_subset(tmp_mask, cfg->domain)) {
-			free_cpumask_var(tmp_mask);
-			return 0;
+			err = 0;
+			if (cpumask_equal(tmp_mask, cfg->domain))
+				break;
+			/*
+			 * New cpumask using the vector is a proper subset of
+			 * the current in use mask. So cleanup the vector
+			 * allocation for the members that are not used anymore.
+			 */
+			cpumask_andnot(cfg->old_domain, cfg->domain, tmp_mask);
+			cfg->move_in_progress = 1;
+			cpumask_and(cfg->domain, cfg->domain, tmp_mask);
+			break;
 		}
 
 		vector = current_vector;
@@ -1172,7 +1171,7 @@ next:
 		/* Found one! */
 		current_vector = vector;
 		current_offset = offset;
-		if (old_vector) {
+		if (cfg->vector) {
 			cfg->move_in_progress = 1;
 			cpumask_copy(cfg->old_domain, cfg->domain);
 		}
diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
index b5d889b..bde78d0 100644
--- a/arch/x86/kernel/apic/x2apic_cluster.c
+++ b/arch/x86/kernel/apic/x2apic_cluster.c
@@ -212,10 +212,10 @@ static int x2apic_cluster_probe(void)
 /*
  * Each x2apic cluster is an allocation domain.
  */
-static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask)
+static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask,
+					     const struct cpumask *mask)
 {
-	cpumask_clear(retmask);
-	cpumask_copy(retmask, per_cpu(cpus_in_cluster, cpu));
+	cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
 }
 
 static struct apic apic_x2apic_cluster = {
-- 
1.7.6.5

Re: [PATCH v2 2/3] x86, x2apic: limit the vector reservation to the user specified mask

[Yinghai Lu]

On Thu, Jun 21, 2012 at 3:02 PM, Suresh Siddha
<suresh.b.siddha@intel.com> wrote:
> For the x2apic cluster mode, vector for an interrupt is currently reserved on
> all the cpu's that are part of the x2apic cluster. But the interrupts will
> be routed only to the cluster (derived from the first cpu in the mask) members
> specified in the mask. So there is no need to reserve the vector in the unused
> cluster members.
>
> Modify __assign_irq_vector() to reserve the vectors based on the user
> specified irq destination mask. If the new mask is a proper subset of
> the currently used mask, cleanup the vector allocation on the unused cpu
> members.
>
> Also, allow the apic driver to tune the vector domain based on the
> affinity mask (which in most cases is the user-specified mask).
>
> Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
> Acked-by: Yinghai Lu <yinghai@kernel.org>
> ---
>  arch/x86/include/asm/apic.h           |    9 ++++++---
>  arch/x86/kernel/apic/apic_noop.c      |    3 ++-
>  arch/x86/kernel/apic/io_apic.c        |   31 +++++++++++++++----------------
>  arch/x86/kernel/apic/x2apic_cluster.c |    6 +++---
>  4 files changed, 26 insertions(+), 23 deletions(-)
>
> diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
> index b37fa12..c276809 100644
> --- a/arch/x86/include/asm/apic.h
> +++ b/arch/x86/include/asm/apic.h
> @@ -306,7 +306,8 @@ struct apic {
>        unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
>        unsigned long (*check_apicid_present)(int apicid);
>
> -       void (*vector_allocation_domain)(int cpu, struct cpumask *retmask);
> +       void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
> +                                        const struct cpumask *mask);

there is one left over for vsmp_64 need to be updated.

arch/x86/kernel/vsmp_64.c: In function ‘vsmp_apic_post_init’:
arch/x86/kernel/vsmp_64.c:221:33: warning: assignment from
incompatible pointer type [enabled by default]

Thanks

Yinghai

Re: [PATCH v2 2/3] x86, x2apic: limit the vector reservation to the user specified mask

[Ingo Molnar]

* Yinghai Lu <yinghai@kernel.org> wrote:

> On Thu, Jun 21, 2012 at 3:02 PM, Suresh Siddha
> <suresh.b.siddha@intel.com> wrote:
> > For the x2apic cluster mode, vector for an interrupt is currently reserved on
> > all the cpu's that are part of the x2apic cluster. But the interrupts will
> > be routed only to the cluster (derived from the first cpu in the mask) members
> > specified in the mask. So there is no need to reserve the vector in the unused
> > cluster members.
> >
> > Modify __assign_irq_vector() to reserve the vectors based on the user
> > specified irq destination mask. If the new mask is a proper subset of
> > the currently used mask, cleanup the vector allocation on the unused cpu
> > members.
> >
> > Also, allow the apic driver to tune the vector domain based on the
> > affinity mask (which in most cases is the user-specified mask).
> >
> > Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
> > Acked-by: Yinghai Lu <yinghai@kernel.org>
> > ---
> >  arch/x86/include/asm/apic.h           |    9 ++++++---
> >  arch/x86/kernel/apic/apic_noop.c      |    3 ++-
> >  arch/x86/kernel/apic/io_apic.c        |   31 +++++++++++++++----------------
> >  arch/x86/kernel/apic/x2apic_cluster.c |    6 +++---
> >  4 files changed, 26 insertions(+), 23 deletions(-)
> >
> > diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
> > index b37fa12..c276809 100644
> > --- a/arch/x86/include/asm/apic.h
> > +++ b/arch/x86/include/asm/apic.h
> > @@ -306,7 +306,8 @@ struct apic {
> >        unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
> >        unsigned long (*check_apicid_present)(int apicid);
> >
> > -       void (*vector_allocation_domain)(int cpu, struct cpumask *retmask);
> > +       void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
> > +                                        const struct cpumask *mask);
> 
> there is one left over for vsmp_64 need to be updated.
> 
> arch/x86/kernel/vsmp_64.c: In function ‘vsmp_apic_post_init’:
> arch/x86/kernel/vsmp_64.c:221:33: warning: assignment from
> incompatible pointer type [enabled by default]

Other than this omission the series looks good to me as well, if 
this is fixed and the Acked-by's of the three gents is added to 
all three patches then I can apply it to -tip.

Thanks,

	Ingo

[PATCH v2 3/3] x86, x2apic: use multiple cluster members for the irq destination only with the explicit affinity

[Suresh Siddha]

During boot or driver load etc, interrupt destination is setup using default
target cpu's. Later the user (irqbalance etc) or the driver (irq_set_affinity/
irq_set_affinity_hint) can request the interrupt to be migrated to some
specific set of cpu's.

In the x2apic cluster routing, for the default scenario use single cpu as the
interrupt destination and when there is an explicit interrupt affinity
request, route the interrupt to multiple members of a x2apic cluster
specified in the cpumask of the migration request.

This will minmize the vector pressure when there are lot of interrupt
sources and relatively few x2apic clusters (for example a single socket
server). This will allow the performance critical interrupts to be
routed to multiple cpu's in the x2apic cluster (irqbalance for example
uses the cache siblings etc while specifying the interrupt destination) and
allow non-critical interrupts to be serviced by a single logical cpu.

Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
---
 arch/x86/kernel/apic/x2apic_cluster.c |   21 +++++++++++++++++++--
 1 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
index bde78d0..c88baa4 100644
--- a/arch/x86/kernel/apic/x2apic_cluster.c
+++ b/arch/x86/kernel/apic/x2apic_cluster.c
@@ -209,13 +209,30 @@ static int x2apic_cluster_probe(void)
 		return 0;
 }
 
+static const struct cpumask *x2apic_cluster_target_cpus(void)
+{
+	return cpu_all_mask;
+}
+
 /*
  * Each x2apic cluster is an allocation domain.
  */
 static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask,
 					     const struct cpumask *mask)
 {
-	cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
+	/*
+	 * To minimize vector pressure, default case of boot, device bringup
+	 * etc will use a single cpu for the interrupt destination.
+	 *
+	 * On explicit migration requests coming from irqbalance etc,
+	 * interrupts will be routed to the x2apic cluster (cluster-id
+	 * derived from the first cpu in the mask) members specified
+	 * in the mask.
+	 */
+	if (mask == x2apic_cluster_target_cpus())
+		cpumask_copy(retmask, cpumask_of(cpu));
+	else
+		cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
 }
 
 static struct apic apic_x2apic_cluster = {
@@ -229,7 +246,7 @@ static struct apic apic_x2apic_cluster = {
 	.irq_delivery_mode		= dest_LowestPrio,
 	.irq_dest_mode			= 1, /* logical */
 
-	.target_cpus			= online_target_cpus,
+	.target_cpus			= x2apic_cluster_target_cpus,
 	.disable_esr			= 0,
 	.dest_logical			= APIC_DEST_LOGICAL,
 	.check_apicid_used		= NULL,
-- 
1.7.6.5

Re: [PATCH v2 3/3] x86, x2apic: use multiple cluster members for the irq destination only with the explicit affinity

[Yinghai Lu]

On Thu, Jun 21, 2012 at 3:02 PM, Suresh Siddha
<suresh.b.siddha@intel.com> wrote:
> During boot or driver load etc, interrupt destination is setup using default
> target cpu's. Later the user (irqbalance etc) or the driver (irq_set_affinity/
> irq_set_affinity_hint) can request the interrupt to be migrated to some
> specific set of cpu's.
>
> In the x2apic cluster routing, for the default scenario use single cpu as the
> interrupt destination and when there is an explicit interrupt affinity
> request, route the interrupt to multiple members of a x2apic cluster
> specified in the cpumask of the migration request.
>
> This will minmize the vector pressure when there are lot of interrupt
> sources and relatively few x2apic clusters (for example a single socket
> server). This will allow the performance critical interrupts to be
> routed to multiple cpu's in the x2apic cluster (irqbalance for example
> uses the cache siblings etc while specifying the interrupt destination) and
> allow non-critical interrupts to be serviced by a single logical cpu.
>
> Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
> ---
>  arch/x86/kernel/apic/x2apic_cluster.c |   21 +++++++++++++++++++--
>  1 files changed, 19 insertions(+), 2 deletions(-)
>
> diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
> index bde78d0..c88baa4 100644
> --- a/arch/x86/kernel/apic/x2apic_cluster.c
> +++ b/arch/x86/kernel/apic/x2apic_cluster.c
> @@ -209,13 +209,30 @@ static int x2apic_cluster_probe(void)
>                return 0;
>  }
>
> +static const struct cpumask *x2apic_cluster_target_cpus(void)
> +{
> +       return cpu_all_mask;
> +}
> +
>  /*
>  * Each x2apic cluster is an allocation domain.
>  */
>  static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask,
>                                             const struct cpumask *mask)
>  {
> -       cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
> +       /*
> +        * To minimize vector pressure, default case of boot, device bringup
> +        * etc will use a single cpu for the interrupt destination.
> +        *
> +        * On explicit migration requests coming from irqbalance etc,
> +        * interrupts will be routed to the x2apic cluster (cluster-id
> +        * derived from the first cpu in the mask) members specified
> +        * in the mask.
> +        */
> +       if (mask == x2apic_cluster_target_cpus())
> +               cpumask_copy(retmask, cpumask_of(cpu));
> +       else
> +               cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));

great, that remove the startup limitation.

Acked-by: Yinghai Lu <yinghai@kernel.org>

>  }
>
>  static struct apic apic_x2apic_cluster = {
> @@ -229,7 +246,7 @@ static struct apic apic_x2apic_cluster = {
>        .irq_delivery_mode              = dest_LowestPrio,
>        .irq_dest_mode                  = 1, /* logical */
>
> -       .target_cpus                    = online_target_cpus,
> +       .target_cpus                    = x2apic_cluster_target_cpus,
>        .disable_esr                    = 0,
>        .dest_logical                   = APIC_DEST_LOGICAL,
>        .check_apicid_used              = NULL,
> --
> 1.7.6.5
>

Re: [PATCH v2 3/3] x86, x2apic: use multiple cluster members for the irq destination only with the explicit affinity

[Alexander Gordeev]

On Thu, Jun 21, 2012 at 03:02:25PM -0700, Suresh Siddha wrote:
> +	if (mask == x2apic_cluster_target_cpus())
> +		cpumask_copy(retmask, cpumask_of(cpu));
> +	else
> +		cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
>  }

Yay, target_cpus() is a way better here.

-- 
Regards,
Alexander Gordeev
agordeev@redhat.com

Re: [PATCH v2 0/3] -tip cleanups/fixes for x2apic cluster mode routing

[Cyrill Gorcunov]

On Thu, Jun 21, 2012 at 03:02:22PM -0700, Suresh Siddha wrote:
> Following patches will reserve the vector only on the cpu's where
> the interrupt will be routed to based on the specified affinity mask
> (not on the complete x2apic cluster which is the current behavior).
...

Great job, thanks Suresh!

	Cyrill