[RFC 00/13] smp: reduce stack requirements for genapic send_IPI_mask functions

[RFC 00/13] smp: reduce stack requirements for genapic send_IPI_mask functions

[Mike Travis]

[Note: all these changes require some more testing but I wanted to solicit
comments before then, hence the "RFC" in the subject line. -thanks! Mike]

  * Change the genapic->send_IPI_mask function to accept cpumask_t pointer.

  * Add for_each_online_cpu_mask_nr to eliminate a common case of needing
    a temporary on-stack cpumask_t variable.

  * Change send_IPI_mask function in xen to use for_each_online_cpu_mask_nr().

  * Add cpumask_ptr operations.

  * Add get_cpumask_var debug operations.

  * Add global allbutself PER_CPUMASK variable.

  * Remove as many on-stack cpumask_t variables in kernel/sched.c

  * Remove as many on-stack cpumask_t variables in acpi-cpufreq.c

  * Remove as many on-stack cpumask_t variables in io_apic.c


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---

-- 

[RFC 01/13] smp: modify send_IPI_mask interface to accept cpumask_t pointers

[Mike Travis]

[-- Attachment #1: send_IPI_mask --]
[-- Type: text/plain, Size: 8075 bytes --]

  * Change the send_IPI_mask interface for x86_64 to accept a pointer
    to the cpumask_t argument.


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/genapic_flat_64.c       |   16 ++++++++--------
 arch/x86/kernel/genx2apic_cluster.c     |    8 ++++----
 arch/x86/kernel/genx2apic_phys.c        |    8 ++++----
 arch/x86/kernel/genx2apic_uv_x.c        |    8 ++++----
 arch/x86/xen/smp.c                      |    9 ++++++---
 include/asm-x86/genapic_64.h            |    2 +-
 include/asm-x86/mach-default/mach_ipi.h |    2 +-
 include/asm-x86/mach-generic/mach_ipi.h |    4 ++++
 8 files changed, 32 insertions(+), 25 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/genapic_flat_64.c
+++ linux-2.6.tip/arch/x86/kernel/genapic_flat_64.c
@@ -69,9 +69,9 @@ static void flat_init_apic_ldr(void)
 	apic_write(APIC_LDR, val);
 }
 
-static void flat_send_IPI_mask(cpumask_t cpumask, int vector)
+static void flat_send_IPI_mask(const cpumask_t *cpumask, int vector)
 {
-	unsigned long mask = cpus_addr(cpumask)[0];
+	unsigned long mask = cpus_addr(*cpumask)[0];
 	unsigned long flags;
 
 	local_irq_save(flags);
@@ -92,7 +92,7 @@ static void flat_send_IPI_allbutself(int
 		cpu_clear(smp_processor_id(), allbutme);
 
 		if (!cpus_empty(allbutme))
-			flat_send_IPI_mask(allbutme, vector);
+			flat_send_IPI_mask(&allbutme, vector);
 	} else if (num_online_cpus() > 1) {
 		__send_IPI_shortcut(APIC_DEST_ALLBUT, vector,APIC_DEST_LOGICAL);
 	}
@@ -101,7 +101,7 @@ static void flat_send_IPI_allbutself(int
 static void flat_send_IPI_all(int vector)
 {
 	if (vector == NMI_VECTOR)
-		flat_send_IPI_mask(cpu_online_map, vector);
+		flat_send_IPI_mask(&cpu_online_map, vector);
 	else
 		__send_IPI_shortcut(APIC_DEST_ALLINC, vector, APIC_DEST_LOGICAL);
 }
@@ -196,9 +196,9 @@ static cpumask_t physflat_vector_allocat
 	return cpumask_of_cpu(cpu);
 }
 
-static void physflat_send_IPI_mask(cpumask_t cpumask, int vector)
+static void physflat_send_IPI_mask(const cpumask_t *cpumask, int vector)
 {
-	send_IPI_mask_sequence(cpumask, vector);
+	send_IPI_mask_sequence(*cpumask, vector);
 }
 
 static void physflat_send_IPI_allbutself(int vector)
@@ -206,12 +206,12 @@ static void physflat_send_IPI_allbutself
 	cpumask_t allbutme = cpu_online_map;
 
 	cpu_clear(smp_processor_id(), allbutme);
-	physflat_send_IPI_mask(allbutme, vector);
+	physflat_send_IPI_mask(&allbutme, vector);
 }
 
 static void physflat_send_IPI_all(int vector)
 {
-	physflat_send_IPI_mask(cpu_online_map, vector);
+	physflat_send_IPI_mask(&cpu_online_map, vector);
 }
 
 static unsigned int physflat_cpu_mask_to_apicid(cpumask_t cpumask)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_cluster.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_cluster.c
@@ -56,13 +56,13 @@ static void __x2apic_send_IPI_dest(unsig
  * at once. We have 16 cpu's in a cluster. This will minimize IPI register
  * writes.
  */
-static void x2apic_send_IPI_mask(cpumask_t mask, int vector)
+static void x2apic_send_IPI_mask(const cpumask_t *mask, int vector)
 {
 	unsigned long flags;
 	unsigned long query_cpu;
 
 	local_irq_save(flags);
-	for_each_cpu_mask(query_cpu, mask) {
+	for_each_cpu_mask_nr(query_cpu, *mask) {
 		__x2apic_send_IPI_dest(per_cpu(x86_cpu_to_logical_apicid, query_cpu),
 				       vector, APIC_DEST_LOGICAL);
 	}
@@ -76,12 +76,12 @@ static void x2apic_send_IPI_allbutself(i
 	cpu_clear(smp_processor_id(), mask);
 
 	if (!cpus_empty(mask))
-		x2apic_send_IPI_mask(mask, vector);
+		x2apic_send_IPI_mask(&mask, vector);
 }
 
 static void x2apic_send_IPI_all(int vector)
 {
-	x2apic_send_IPI_mask(cpu_online_map, vector);
+	x2apic_send_IPI_mask(&cpu_online_map, vector);
 }
 
 static int x2apic_apic_id_registered(void)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_phys.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_phys.c
@@ -54,13 +54,13 @@ static void __x2apic_send_IPI_dest(unsig
 	x2apic_icr_write(cfg, apicid);
 }
 
-static void x2apic_send_IPI_mask(cpumask_t mask, int vector)
+static void x2apic_send_IPI_mask(const cpumask_t *mask, int vector)
 {
 	unsigned long flags;
 	unsigned long query_cpu;
 
 	local_irq_save(flags);
-	for_each_cpu_mask(query_cpu, mask) {
+	for_each_cpu_mask_nr(query_cpu, *mask) {
 		__x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu),
 				       vector, APIC_DEST_PHYSICAL);
 	}
@@ -74,12 +74,12 @@ static void x2apic_send_IPI_allbutself(i
 	cpu_clear(smp_processor_id(), mask);
 
 	if (!cpus_empty(mask))
-		x2apic_send_IPI_mask(mask, vector);
+		x2apic_send_IPI_mask(&mask, vector);
 }
 
 static void x2apic_send_IPI_all(int vector)
 {
-	x2apic_send_IPI_mask(cpu_online_map, vector);
+	x2apic_send_IPI_mask(&cpu_online_map, vector);
 }
 
 static int x2apic_apic_id_registered(void)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_uv_x.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_uv_x.c
@@ -124,12 +124,12 @@ static void uv_send_IPI_one(int cpu, int
 	uv_write_global_mmr64(pnode, UVH_IPI_INT, val);
 }
 
-static void uv_send_IPI_mask(cpumask_t mask, int vector)
+static void uv_send_IPI_mask(const cpumask_t *mask, int vector)
 {
 	unsigned int cpu;
 
 	for_each_possible_cpu(cpu)
-		if (cpu_isset(cpu, mask))
+		if (cpu_isset(cpu, *mask))
 			uv_send_IPI_one(cpu, vector);
 }
 
@@ -140,12 +140,12 @@ static void uv_send_IPI_allbutself(int v
 	cpu_clear(smp_processor_id(), mask);
 
 	if (!cpus_empty(mask))
-		uv_send_IPI_mask(mask, vector);
+		uv_send_IPI_mask(&mask, vector);
 }
 
 static void uv_send_IPI_all(int vector)
 {
-	uv_send_IPI_mask(cpu_online_map, vector);
+	uv_send_IPI_mask(&cpu_online_map, vector);
 }
 
 static int uv_apic_id_registered(void)
--- linux-2.6.tip.orig/arch/x86/xen/smp.c
+++ linux-2.6.tip/arch/x86/xen/smp.c
@@ -358,10 +358,12 @@ static void xen_smp_send_reschedule(int 
 	xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
 }
 
-static void xen_send_IPI_mask(cpumask_t mask, enum ipi_vector vector)
+static void xen_send_IPI_mask(const cpumask_t *inmask, enum ipi_vector vector)
 {
 	unsigned cpu;
+	cpumask_t mask;
 
+	mask = *inmask;
 	cpus_and(mask, mask, cpu_online_map);
 
 	for_each_cpu_mask_nr(cpu, mask)
@@ -372,7 +374,7 @@ static void xen_smp_send_call_function_i
 {
 	int cpu;
 
-	xen_send_IPI_mask(*mask, XEN_CALL_FUNCTION_VECTOR);
+	xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
 
 	/* Make sure other vcpus get a chance to run if they need to. */
 	for_each_cpu_mask_nr(cpu, *mask) {
@@ -385,7 +387,8 @@ static void xen_smp_send_call_function_i
 
 static void xen_smp_send_call_function_single_ipi(int cpu)
 {
-	xen_send_IPI_mask(cpumask_of_cpu(cpu), XEN_CALL_FUNCTION_SINGLE_VECTOR);
+	xen_send_IPI_mask(&cpumask_of_cpu(cpu),
+			  XEN_CALL_FUNCTION_SINGLE_VECTOR);
 }
 
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
--- linux-2.6.tip.orig/include/asm-x86/genapic_64.h
+++ linux-2.6.tip/include/asm-x86/genapic_64.h
@@ -22,7 +22,7 @@ struct genapic {
 	cpumask_t (*vector_allocation_domain)(int cpu);
 	void (*init_apic_ldr)(void);
 	/* ipi */
-	void (*send_IPI_mask)(cpumask_t mask, int vector);
+	void (*send_IPI_mask)(const cpumask_t *mask, int vector);
 	void (*send_IPI_allbutself)(int vector);
 	void (*send_IPI_all)(int vector);
 	void (*send_IPI_self)(int vector);
--- linux-2.6.tip.orig/include/asm-x86/mach-default/mach_ipi.h
+++ linux-2.6.tip/include/asm-x86/mach-default/mach_ipi.h
@@ -11,7 +11,7 @@ extern int no_broadcast;
 
 #ifdef CONFIG_X86_64
 #include <asm/genapic.h>
-#define send_IPI_mask (genapic->send_IPI_mask)
+#define send_IPI_mask(mask, vector) (genapic->send_IPI_mask)(&(mask), vector)
 #else
 static inline void send_IPI_mask(cpumask_t mask, int vector)
 {
--- linux-2.6.tip.orig/include/asm-x86/mach-generic/mach_ipi.h
+++ linux-2.6.tip/include/asm-x86/mach-generic/mach_ipi.h
@@ -3,7 +3,11 @@
 
 #include <asm/genapic.h>
 
+#ifdef CONFIG_X86_64
+#define send_IPI_mask(mask, vector) (genapic->send_IPI_mask)(&(mask), vector)
+#else
 #define send_IPI_mask (genapic->send_IPI_mask)
+#endif
 #define send_IPI_allbutself (genapic->send_IPI_allbutself)
 #define send_IPI_all (genapic->send_IPI_all)
 

-- 

[RFC 02/13] cpumask: add for_each_online_cpu_mask_nr function

[Mike Travis]

[-- Attachment #1: for_each_online_cpu_mask_nr --]
[-- Type: text/plain, Size: 4303 bytes --]

  * Add for_each_online_cpu_mask_nr() function to eliminate need for
    a common use of a temporary cpumask_t variable.  When the following
    procedure is being used:

    funcproto(cpumask_t *mask, ...)
	cpumask_t temp;

	cpus_and(temp, *mask, cpu_online_map);
	for_each_cpu_mask_nr(cpu, temp)
		...

    If then becomes:

	for_each_online_cpu_mask_nr(cpu, *mask)
		...

  * Note the generic __next_cpu_and (and __next_cpu_and_nr) functions
    allowing AND'ing with any cpumask_t variable, not just the cpu_online_map.


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 include/linux/cpumask.h |   26 +++++++++++++++++++++++---
 lib/cpumask.c           |   26 ++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 3 deletions(-)

--- linux-2.6.tip.orig/include/linux/cpumask.h
+++ linux-2.6.tip/include/linux/cpumask.h
@@ -404,23 +404,32 @@ static inline void __cpus_fold(cpumask_t
 #define first_cpu(src)		({ (void)(src); 0; })
 #define next_cpu(n, src)	({ (void)(src); 1; })
 #define any_online_cpu(mask)	0
-#define for_each_cpu_mask(cpu, mask)	\
+
+#define for_each_cpu_mask(cpu, mask)		\
 	for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
+#define for_each_online_cpu_mask(cpu, mask)	\
+	for_each_cpu_mask(cpu, mask)
 
 #else /* NR_CPUS > 1 */
 
 extern int nr_cpu_ids;
 int __first_cpu(const cpumask_t *srcp);
 int __next_cpu(int n, const cpumask_t *srcp);
+int __next_cpu_and(int n, const cpumask_t *srcp, const cpumask_t *andp);
 int __any_online_cpu(const cpumask_t *mask);
 
 #define first_cpu(src)		__first_cpu(&(src))
 #define next_cpu(n, src)	__next_cpu((n), &(src))
 #define any_online_cpu(mask) __any_online_cpu(&(mask))
+
 #define for_each_cpu_mask(cpu, mask)			\
 	for ((cpu) = -1;				\
 		(cpu) = next_cpu((cpu), (mask)),	\
 		(cpu) < NR_CPUS; )
+#define for_each_online_cpu_mask(cpu, mask)				   \
+	for ((cpu) = -1;						   \
+		(cpu) = __next_cpu_and((cpu), &(mask), &(cpu_online_map)), \
+		(cpu) < NR_CPUS; )
 #endif
 
 #if NR_CPUS <= 64
@@ -428,17 +437,28 @@ int __any_online_cpu(const cpumask_t *ma
 #define next_cpu_nr(n, src)		next_cpu(n, src)
 #define cpus_weight_nr(cpumask)		cpus_weight(cpumask)
 #define for_each_cpu_mask_nr(cpu, mask)	for_each_cpu_mask(cpu, mask)
+#define for_each_online_cpu_mask_nr(cpu, mask)	\
+					for_each_online_cpu_mask(cpu, mask)
 
 #else /* NR_CPUS > 64 */
 
 int __next_cpu_nr(int n, const cpumask_t *srcp);
-#define next_cpu_nr(n, src)	__next_cpu_nr((n), &(src))
-#define cpus_weight_nr(cpumask)	__cpus_weight(&(cpumask), nr_cpu_ids)
+int __next_cpu_and_nr(int n, const cpumask_t *srcp, const cpumask_t *andp);
+
+#define next_cpu_nr(n, src)		__next_cpu_nr((n), &(src))
+#define next_cpu_and_nr(n, src, and)	__next_cpu_and_nr((n), &(src), &(and))
+#define cpus_weight_nr(cpumask)		__cpus_weight(&(cpumask), nr_cpu_ids)
+
 #define for_each_cpu_mask_nr(cpu, mask)			\
 	for ((cpu) = -1;				\
 		(cpu) = next_cpu_nr((cpu), (mask)),	\
 		(cpu) < nr_cpu_ids; )
 
+#define for_each_online_cpu_mask_nr(cpu, mask)				  \
+	for ((cpu) = -1;						  \
+		(cpu) = next_cpu_and_nr((cpu), (mask), (cpu_online_map)), \
+		(cpu) < nr_cpu_ids; )
+
 #endif /* NR_CPUS > 64 */
 
 /*
--- linux-2.6.tip.orig/lib/cpumask.c
+++ linux-2.6.tip/lib/cpumask.c
@@ -14,6 +14,19 @@ int __next_cpu(int n, const cpumask_t *s
 	return min_t(int, NR_CPUS, find_next_bit(srcp->bits, NR_CPUS, n+1));
 }
 EXPORT_SYMBOL(__next_cpu);
+int __next_cpu_and(int n, const cpumask_t *srcp, const cpumask_t *andp)
+{
+	int cpu;
+
+	for (cpu = n + 1; cpu < NR_CPUS; cpu++) {
+		cpu = find_next_bit(srcp->bits, NR_CPUS, cpu);
+
+		if (cpu < NR_CPUS && cpu_isset(cpu, *andp))
+			return cpu;
+	}
+	return NR_CPUS;
+}
+EXPORT_SYMBOL(__next_cpu_and);
 
 #if NR_CPUS > 64
 int __next_cpu_nr(int n, const cpumask_t *srcp)
@@ -22,6 +35,19 @@ int __next_cpu_nr(int n, const cpumask_t
 				find_next_bit(srcp->bits, nr_cpu_ids, n+1));
 }
 EXPORT_SYMBOL(__next_cpu_nr);
+int __next_cpu_and_nr(int n, const cpumask_t *srcp, const cpumask_t *andp)
+{
+	int cpu;
+
+	for (cpu = n + 1; cpu < nr_cpu_ids; cpu++) {
+		cpu = find_next_bit(srcp->bits, nr_cpu_ids, cpu);
+
+		if (cpu < nr_cpu_ids && cpu_isset(cpu, *andp))
+			return cpu;
+	}
+	return nr_cpu_ids;
+}
+EXPORT_SYMBOL(__next_cpu_and_nr);
 #endif
 
 int __any_online_cpu(const cpumask_t *mask)

-- 

[RFC 03/13] xen: use new for_each_online_cpu_mask_nr function

[Mike Travis]

[-- Attachment #1: xen-send_IPI_mask --]
[-- Type: text/plain, Size: 833 bytes --]

  * Change the send_IPI_mask function in xen to not require a local
    cpumask_t variable.

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/xen/smp.c |    8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

--- linux-2.6.tip.orig/arch/x86/xen/smp.c
+++ linux-2.6.tip/arch/x86/xen/smp.c
@@ -358,15 +358,11 @@ static void xen_smp_send_reschedule(int 
 	xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
 }
 
-static void xen_send_IPI_mask(const cpumask_t *inmask, enum ipi_vector vector)
+static void xen_send_IPI_mask(const cpumask_t *mask, enum ipi_vector vector)
 {
 	unsigned cpu;
-	cpumask_t mask;
 
-	mask = *inmask;
-	cpus_and(mask, mask, cpu_online_map);
-
-	for_each_cpu_mask_nr(cpu, mask)
+	for_each_online_cpu_mask_nr(cpu, *mask)
 		xen_send_IPI_one(cpu, vector);
 }
 

-- 

[RFC 04/13] cpumask: add cpumask_ptr operations

[Mike Travis]

[-- Attachment #1: get_cpumask_ptr --]
[-- Type: text/plain, Size: 4671 bytes --]

 * Define a generic cpumask_ptr type and some helper functions that
 * do not add any overhead to low count NR_CPUS systems.  Essentially
 * for NR_CPUS <= BITS_PER_LONG, an array of one cpumask is created on
 * the stack.  For larger count systems, a pointer is defined.  In both
 * cases the pointer variable can be used as C will optimize out the
 * pointer derefence in the small system case.
 *
 * Add a simple kmalloc to allocate a temporary cpumask variable.
 * (Note, kmalloc should be defined before including this file.)
 *
 * Add a simple per_cpu variable to facilitate those cases where a
 * kmalloc failure cannot be reasonable handled (or we're using it
 * before the mm system is initialized.)
 *
 * This is useful for getting temporary per_cpu cpumask_t variables.
 * Note there are no locks, so these are _extremely_ temporary cpumask
 * vars, with only preemption disabled, while in use.
 *
 * Many thanks to Linus Torvalds for the typedef/alloc idea.
 *
 * Adds the following cpumask_ptr operations for NR_CPUS > BITS_PER_LONG:
 *
 *   cpumask_ptr p;		Declares p to be a cpumask_t pointer
 *
 *   alloc_cpumask_ptr(p);	allocates and assigns memory to p
 *   free_cpumask_ptr(p);	frees memory used by p
 *
 *   DEFINE_PER_CPUMASK(p, v)	Defines a PER_CPUMASK variable v
 *   DECLARE_PER_CPUMASK(p, v)	Declares a PER_CPUMASK variable v
 *   get_cpumask_var(p, v)	Obtains possession of PER_CPUMASK variable v
 *   				and assignes it to p
 *   put_cpumask_var(p, v)	Relenquishs possession of PER_CPUMASK variable v
 *
 * If NR_CPUS <= BITS_PER_LONG then the above are all essentially NOP's.

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 include/linux/cpumask_ptr.h |   78 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

--- /dev/null
+++ linux-2.6.tip/include/linux/cpumask_ptr.h
@@ -0,0 +1,78 @@
+#ifndef __LINUX_CPUMASK_PTR_H
+#define __LINUX_CPUMASK_PTR_H
+
+/*
+ * Define a generic cpumask_ptr type and some helper functions that
+ * do not add any overhead to low count NR_CPUS systems.  Essentially
+ * for NR_CPUS <= BITS_PER_LONG, an array of one cpumask is created on
+ * the stack.  For larger count systems, a pointer is defined.  In both
+ * cases the pointer variable can be used as C will optimize out the
+ * pointer derefence in the small system case.
+ *
+ * Add a simple kmalloc to allocate a temporary cpumask variable.
+ * (Note, kmalloc should be defined before including this file.)
+ *
+ * Add a simple per_cpu variable to facilitate those cases where a
+ * kmalloc failure cannot be reasonable handled (or we're using it
+ * before the mm system is initialized.)
+ *
+ * This is useful for getting temporary per_cpu cpumask_t variables.
+ * Note there are no locks, so these are _extremely_ temporary cpumask
+ * vars, with only preemption disabled, while in use.
+ *
+ * Many thanks to Linus Torvalds for the typedef/alloc idea.
+ *
+ * Adds the following cpumask_ptr operations for NR_CPUS > BITS_PER_LONG:
+ *
+ *   cpumask_ptr p;		Declares p to be a cpumask_t pointer
+ *
+ *   alloc_cpumask_ptr(p);	allocates and assigns memory to p
+ *   free_cpumask_ptr(p);	frees memory used by p
+ *
+ *   DEFINE_PER_CPUMASK(p, v)	Defines a PER_CPUMASK variable v
+ *   DECLARE_PER_CPUMASK(p, v)	Declares a PER_CPUMASK variable v
+ *   get_cpumask_var(p, v)	Obtains possession of PER_CPUMASK variable v
+ *   				and assignes it to p
+ *   put_cpumask_var(p, v)	Relenquishs possession of PER_CPUMASK variable v
+ *
+ * If NR_CPUS <= BITS_PER_LONG then the above are all essentially NOP's.
+ */
+
+#if NR_CPUS <= BITS_PER_LONG
+
+typedef cpumask_t cpumask_ptr[1];
+static inline void alloc_cpumask_ptr(cpumask_ptr *p)
+{
+}
+static inline void free_cpumask_ptr(cpumask_ptr *p)
+{
+}
+#define	DEFINE_PER_CPUMASK(v)	void *unused_##v __maybe_unused
+#define	DECLARE_PER_CPUMASK(v)
+#define get_cpumask_var(p, v)	do { } while(0)
+#define put_cpumask_var(p, v)	do { } while(0)
+
+#else /* NR_CPUS > BITS_PER_LONG */
+
+#include <linux/slab.h>
+typedef cpumask_t *cpumask_ptr;
+static inline void _get_cpumask_ptr(cpumask_ptr *p, cpumask_t *m)
+{
+	*p = m;
+}
+static inline void alloc_cpumask_ptr(cpumask_ptr *p)
+{
+	_get_cpumask_ptr(p, kmalloc(sizeof(cpumask_t), GFP_KERNEL));
+}
+static inline void free_cpumask_ptr(cpumask_ptr *p)
+{
+	kfree(*p);
+}
+#define	DEFINE_PER_CPUMASK(v)	DEFINE_PER_CPU(cpumask_t, v)
+#define	DECLARE_PER_CPUMASK(v)	DECLARE_PER_CPU(cpumask_t, v)
+#define	get_cpumask_var(p, v)	_get_cpumask_ptr(&(p), &get_cpu_var(v))
+#define	put_cpumask_var(p, v)	put_cpu_var(v)
+
+#endif /* NR_CPUS > BITS_PER_LONG */
+
+#endif /* __LINUX_CPUMASK_PTR_H */

-- 

[RFC 05/13] cpumask: add get_cpumask_var debug operations

[Mike Travis]

[-- Attachment #1: get_cpumask_var-debug --]
[-- Type: text/plain, Size: 2459 bytes --]

  * Adds debugging to the get_cpumask_var operations.  It uses a primitive
    per_cpu lock variable and will only discover nested get_cpumask_var
    operations on the same variable.

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/Kconfig.debug      |   12 ++++++++++++
 include/linux/cpumask_ptr.h |   34 ++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

--- linux-2.6.tip.orig/arch/x86/Kconfig.debug
+++ linux-2.6.tip/arch/x86/Kconfig.debug
@@ -92,6 +92,18 @@ config DEBUG_PER_CPU_MAPS
 
 	  Say N if unsure.
 
+config DEBUG_PER_CPUMASK_VAR
+	bool "Debug per_cpumask variables"
+	depends on DEBUG_KERNEL
+	depends on X86_SMP
+	default n
+	help
+	  Say Y to verify that the per_cpumask variables being accessed
+	  are available.  Adds a fair amount of code to kernel memory
+	  and decreases performance.
+
+	  Say N if unsure.
+
 config X86_PTDUMP
 	bool "Export kernel pagetable layout to userspace via debugfs"
 	depends on DEBUG_KERNEL
--- linux-2.6.tip.orig/include/linux/cpumask_ptr.h
+++ linux-2.6.tip/include/linux/cpumask_ptr.h
@@ -53,11 +53,45 @@ static inline void free_cpumask_ptr(cpum
 {
 	kfree(*p);
 }
+
+#ifndef CONFIG_DEBUG_CPUMASK_VAR
 #define	DEFINE_PER_CPUMASK(v)	DEFINE_PER_CPU(cpumask_t, v)
 #define	DECLARE_PER_CPUMASK(v)	DECLARE_PER_CPU(cpumask_t, v)
 #define	get_cpumask_var(p, v)	_get_cpumask_ptr(&(p), &get_cpu_var(v))
 #define	put_cpumask_var(p, v)	put_cpu_var(v)
 
+#else /* CONFIG_DEBUG_CPUMASK_VAR */
+#define	DEFINE_PER_CPUMASK(v)	DEFINE_PER_CPU(cpumask_t, v);	\
+				DEFINE_PER_CPU(char, lock_##v)
+#define	DECLARE_PER_CPUMASK(v)	DECLARE_PER_CPU(cpumask_t, v);	\
+				DECLARE_PER_CPU(char, lock_##v)
+
+#define	get_cpumask_var(p, v)	{				\
+	char *lock = &get_cpu_var(lock_##v);			\
+	if (*lock) {						\
+		printk(KERN_NOTICE "get_cpumask_var(" v "): "	\
+			"already locked!\n");			\
+		dump_stack();					\
+		BUG();						\
+	}							\
+	*lock = 1;						\
+	_get_cpumask_ptr(&(p), &get_cpu_var(v))			\
+	put_cpu_var(lock_##v);					\
+}
+
+#define	put_cpumask_var(p, v)	{				\
+	char *lock = &get_cpu_var(lock_##v);			\
+	if (!*lock) {						\
+		printk(KERN_NOTICE "put_cpumask_var(" v "): "	\
+			"not locked!\n");			\
+		dump_stack();					\
+	}							\
+	*lock = 0;						\
+	put_cpu_var(lock_##v);					\
+	put_cpu_var(v);						\
+}
+#endif /* CONFIG_DEBUG_CPUMASK_VAR */
+
 #endif /* NR_CPUS > BITS_PER_LONG */
 
 #endif /* __LINUX_CPUMASK_PTR_H */

-- 

[RFC 06/13] genapic: use get_cpumask_var operations for allbutself cpumask_ts

[Mike Travis]

[-- Attachment #1: add-percpu-allbutself --]
[-- Type: text/plain, Size: 8622 bytes --]

  * Adds a global allbutself PER_CPUMASK variable and modifies functions
    that create a temp cpumask variable for the following procedure:

	cpumask_t mask = cpu_online_map;
 
	cpu_clear(smp_processor_id(), mask);
 
	if (!cpus_empty(mask))
		XXX_send_IPI_mask(&mask, vector);

    This then becomes:

	cpumask_ptr mask;
 
	get_cpumask_var(mask, allbutself);
	*mask = cpu_online_map;
	cpu_clear(smp_processor_id(), *mask);
 
	if (!cpus_empty(*mask))
		XXX_send_IPI_mask(mask, vector);

	put_cpumask_var(mask, allbutself);

  * Note: this "allbutself" per_cpumask variable could be pre-built during
    system startup saving execution time, but would require that all the
    per_cpumask variables are updated whenever a cpu goes off- or on-line.


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/apic.c                  |    3 +++
 arch/x86/kernel/genapic_flat_64.c       |   26 +++++++++++++++++++-------
 arch/x86/kernel/genx2apic_cluster.c     |   13 +++++++++----
 arch/x86/kernel/genx2apic_uv_x.c        |   13 +++++++++----
 arch/x86/kernel/smp.c                   |   28 ++++++++++++++++++++++++----
 include/asm-x86/genapic_32.h            |    2 ++
 include/asm-x86/genapic_64.h            |    4 ++++
 include/asm-x86/mach-default/mach_ipi.h |   14 ++++++++++----
 8 files changed, 80 insertions(+), 23 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/apic.c
+++ linux-2.6.tip/arch/x86/kernel/apic.c
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/dmi.h>
 #include <linux/dmar.h>
+#include <linux/cpumask_ptr.h>
 
 #include <asm/atomic.h>
 #include <asm/smp.h>
@@ -162,6 +163,8 @@ static DEFINE_PER_CPU(struct clock_event
 
 static unsigned long apic_phys;
 
+DEFINE_PER_CPUMASK(allbutself);
+
 /*
  * Get the LAPIC version
  */
--- linux-2.6.tip.orig/arch/x86/kernel/genapic_flat_64.c
+++ linux-2.6.tip/arch/x86/kernel/genapic_flat_64.c
@@ -11,6 +11,7 @@
 #include <linux/errno.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
+#include <linux/cpumask_ptr.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/ctype.h>
@@ -87,12 +88,17 @@ static void flat_send_IPI_allbutself(int
 	int hotplug = 0;
 #endif
 	if (hotplug || vector == NMI_VECTOR) {
-		cpumask_t allbutme = cpu_online_map;
+		cpumask_ptr mask;
 
-		cpu_clear(smp_processor_id(), allbutme);
+		get_cpumask_var(mask, allbutself);
+		*mask = cpu_online_map;
+		cpu_clear(smp_processor_id(), *mask);
+
+		if (!cpus_empty(*mask))
+			flat_send_IPI_mask(mask, vector);
+
+		put_cpumask_var(mask, allbutself);
 
-		if (!cpus_empty(allbutme))
-			flat_send_IPI_mask(&allbutme, vector);
 	} else if (num_online_cpus() > 1) {
 		__send_IPI_shortcut(APIC_DEST_ALLBUT, vector,APIC_DEST_LOGICAL);
 	}
@@ -205,10 +211,16 @@ static void physflat_send_IPI_mask(const
 
 static void physflat_send_IPI_allbutself(int vector)
 {
-	cpumask_t allbutme = cpu_online_map;
+	cpumask_ptr mask;
+
+	get_cpumask_var(mask, allbutself);
+	*mask = cpu_online_map;
+	cpu_clear(smp_processor_id(), *mask);
+
+	if (!cpus_empty(*mask))
+		physflat_send_IPI_mask(mask, vector);
 
-	cpu_clear(smp_processor_id(), allbutme);
-	physflat_send_IPI_mask(&allbutme, vector);
+	put_cpumask_var(mask, allbutself);
 }
 
 static void physflat_send_IPI_all(int vector)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_cluster.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_cluster.c
@@ -1,5 +1,6 @@
 #include <linux/threads.h>
 #include <linux/cpumask.h>
+#include <linux/cpumask_ptr.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/ctype.h>
@@ -71,12 +72,16 @@ static void x2apic_send_IPI_mask(const c
 
 static void x2apic_send_IPI_allbutself(int vector)
 {
-	cpumask_t mask = cpu_online_map;
+	cpumask_ptr mask;
 
-	cpu_clear(smp_processor_id(), mask);
+	get_cpumask_var(mask, allbutself);
+	*mask = cpu_online_map;
+	cpu_clear(smp_processor_id(), *mask);
 
-	if (!cpus_empty(mask))
-		x2apic_send_IPI_mask(&mask, vector);
+	if (!cpus_empty(*mask))
+		x2apic_send_IPI_mask(mask, vector);
+
+	put_cpumask_var(mask, allbutself);
 }
 
 static void x2apic_send_IPI_all(int vector)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_uv_x.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_uv_x.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/threads.h>
 #include <linux/cpumask.h>
+#include <linux/cpumask_ptr.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/init.h>
@@ -135,12 +136,16 @@ static void uv_send_IPI_mask(const cpuma
 
 static void uv_send_IPI_allbutself(int vector)
 {
-	cpumask_t mask = cpu_online_map;
+	cpumask_ptr mask;
 
-	cpu_clear(smp_processor_id(), mask);
+	get_cpumask_var(mask, allbutself);
+	*mask = cpu_online_map;
+	cpu_clear(smp_processor_id(), *mask);
 
-	if (!cpus_empty(mask))
-		uv_send_IPI_mask(&mask, vector);
+	if (!cpus_empty(*mask))
+		uv_send_IPI_mask(mask, vector);
+
+	put_cpumask_var(mask, allbutself);
 }
 
 static void uv_send_IPI_all(int vector)
--- linux-2.6.tip.orig/arch/x86/kernel/smp.c
+++ linux-2.6.tip/arch/x86/kernel/smp.c
@@ -21,6 +21,7 @@
 #include <linux/cache.h>
 #include <linux/interrupt.h>
 #include <linux/cpu.h>
+#include <linux/cpumask_ptr.h>
 
 #include <asm/mtrr.h>
 #include <asm/tlbflush.h>
@@ -128,16 +129,35 @@ void native_send_call_func_single_ipi(in
 
 void native_send_call_func_ipi(const cpumask_t *mask)
 {
-	cpumask_t allbutself;
 
-	allbutself = cpu_online_map;
-	cpu_clear(smp_processor_id(), allbutself);
+#ifndef	ARCH_DOES_NOT_HAVE_ALLBUTSELF_IPI_CALL
+	/*
+	 * Can't use global "allbutself" because many of the
+	 * genapic->send_IPI_allbutself functions use it to
+	 * expand to a mask to send to each cpu as they do not
+	 * have a single IPI call to send to "allbutself".
+	 *
+	 * This is here only for the small count NR_CPUS that actually
+	 * have one of those handy functions.
+	 *
+	 * There might be an ifdef I could use to short-circuit this out...?
+	 */
+	static DEFINE_PER_CPUMASK(smp_temp_cpumask);
+	cpumask_ptr allbutself;
+
+	get_cpumask_var(allbutself, smp_temp_cpumask);
+	*allbutself = cpu_online_map;
+	cpu_clear(smp_processor_id(), *allbutself);
 
-	if (cpus_equal(*mask, allbutself) &&
+	if (cpus_equal(*mask, *allbutself) &&
 	    cpus_equal(cpu_online_map, cpu_callout_map))
 		send_IPI_allbutself(CALL_FUNCTION_VECTOR);
 	else
 		send_IPI_mask(*mask, CALL_FUNCTION_VECTOR);
+	put_cpumask_var(allbutself, smp_temp_cpumask);
+#else
+	send_IPI_mask(*mask, CALL_FUNCTION_VECTOR);
+#endif
 }
 
 static void stop_this_cpu(void *dummy)
--- linux-2.6.tip.orig/include/asm-x86/genapic_32.h
+++ linux-2.6.tip/include/asm-x86/genapic_32.h
@@ -2,6 +2,7 @@
 #define ASM_X86__GENAPIC_32_H
 
 #include <asm/mpspec.h>
+#include <linux/cpumask_ptr.h>
 
 /*
  * Generic APIC driver interface.
@@ -122,5 +123,6 @@ enum uv_system_type {UV_NONE, UV_LEGACY_
 #define uv_wakeup_secondary(a, b)	1
 #define uv_system_init()		do {} while (0)
 
+DECLARE_PER_CPUMASK(allbutself);
 
 #endif /* ASM_X86__GENAPIC_32_H */
--- linux-2.6.tip.orig/include/asm-x86/genapic_64.h
+++ linux-2.6.tip/include/asm-x86/genapic_64.h
@@ -1,6 +1,8 @@
 #ifndef ASM_X86__GENAPIC_64_H
 #define ASM_X86__GENAPIC_64_H
 
+#include <linux/cpumask_ptr.h>
+
 /*
  * Copyright 2004 James Cleverdon, IBM.
  * Subject to the GNU Public License, v.2
@@ -55,4 +57,6 @@ extern int uv_wakeup_secondary(int phys_
 
 extern void setup_apic_routing(void);
 
+DECLARE_PER_CPUMASK(allbutself);
+
 #endif /* ASM_X86__GENAPIC_64_H */
--- linux-2.6.tip.orig/include/asm-x86/mach-default/mach_ipi.h
+++ linux-2.6.tip/include/asm-x86/mach-default/mach_ipi.h
@@ -1,6 +1,8 @@
 #ifndef ASM_X86__MACH_DEFAULT__MACH_IPI_H
 #define ASM_X86__MACH_DEFAULT__MACH_IPI_H
 
+#include <linux/cpumask_ptr.h>
+
 /* Avoid include hell */
 #define NMI_VECTOR 0x02
 
@@ -9,8 +11,9 @@ void __send_IPI_shortcut(unsigned int sh
 
 extern int no_broadcast;
 
-#ifdef CONFIG_X86_64
 #include <asm/genapic.h>
+
+#ifdef CONFIG_X86_64
 #define send_IPI_mask(mask, vector) (genapic->send_IPI_mask)(&(mask), vector)
 #else
 static inline void send_IPI_mask(cpumask_t mask, int vector)
@@ -22,10 +25,13 @@ static inline void send_IPI_mask(cpumask
 static inline void __local_send_IPI_allbutself(int vector)
 {
 	if (no_broadcast || vector == NMI_VECTOR) {
-		cpumask_t mask = cpu_online_map;
+		cpumask_ptr mask;
 
-		cpu_clear(smp_processor_id(), mask);
-		send_IPI_mask(mask, vector);
+		get_cpumask_var(mask, allbutself);
+		*mask = cpu_online_map;
+		cpu_clear(smp_processor_id(), *mask);
+		send_IPI_mask(*mask, vector);
+		put_cpumask_var(mask, allbutself);
 	} else
 		__send_IPI_shortcut(APIC_DEST_ALLBUT, vector);
 }

-- 

[RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Mike Travis]

[-- Attachment #1: stack-hogs-kernel_sched_c --]
[-- Type: text/plain, Size: 13839 bytes --]

  * Make the following changes to kernel/sched.c functions:

    - use node_to_cpumask_ptr in place of node_to_cpumask
    - use get_cpumask_var for temporary cpumask_t variables
    - use alloc_cpumask_ptr where available

  * Remove special code for SCHED_CPUMASK_ALLOC and use CPUMASK_ALLOC
    from linux/cpumask.h.

  * The resultant stack savings are:

    ====== Stack (-l 100)

	1 - initial
	2 - stack-hogs-kernel_sched_c
	'.' is less than the limit(100)

       .1.    .2.    ..final..
      2216  -1536 680   -69%  __build_sched_domains
      1592  -1592   .  -100%  move_task_off_dead_cpu
      1096  -1096   .  -100%  sched_balance_self
      1032  -1032   .  -100%  sched_setaffinity
       616   -616   .  -100%  rebalance_domains
       552   -552   .  -100%  free_sched_groups
       512   -512   .  -100%  cpu_to_allnodes_group
      7616  -6936 680   -91%  Totals


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 kernel/sched.c |  151 ++++++++++++++++++++++++++++++---------------------------
 1 file changed, 81 insertions(+), 70 deletions(-)

--- linux-2.6.tip.orig/kernel/sched.c
+++ linux-2.6.tip/kernel/sched.c
@@ -70,6 +70,7 @@
 #include <linux/bootmem.h>
 #include <linux/debugfs.h>
 #include <linux/ctype.h>
+#include <linux/cpumask_ptr.h>
 #include <linux/ftrace.h>
 #include <trace/sched.h>
 
@@ -117,6 +118,12 @@
  */
 #define RUNTIME_INF	((u64)~0ULL)
 
+/*
+ * temp cpumask variables
+ */
+static DEFINE_PER_CPUMASK(temp_cpumask_1);
+static DEFINE_PER_CPUMASK(temp_cpumask_2);
+
 #ifdef CONFIG_SMP
 /*
  * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
@@ -2141,7 +2148,11 @@ static int sched_balance_self(int cpu, i
 {
 	struct task_struct *t = current;
 	struct sched_domain *tmp, *sd = NULL;
+	cpumask_ptr span;
+	cpumask_ptr tmpmask;
 
+	get_cpumask_var(span, temp_cpumask_1);
+	get_cpumask_var(tmpmask, temp_cpumask_2);
 	for_each_domain(cpu, tmp) {
 		/*
 		 * If power savings logic is enabled for a domain, stop there.
@@ -2156,7 +2167,6 @@ static int sched_balance_self(int cpu, i
 		update_shares(sd);
 
 	while (sd) {
-		cpumask_t span, tmpmask;
 		struct sched_group *group;
 		int new_cpu, weight;
 
@@ -2165,14 +2175,14 @@ static int sched_balance_self(int cpu, i
 			continue;
 		}
 
-		span = sd->span;
+		*span = sd->span;
 		group = find_idlest_group(sd, t, cpu);
 		if (!group) {
 			sd = sd->child;
 			continue;
 		}
 
-		new_cpu = find_idlest_cpu(group, t, cpu, &tmpmask);
+		new_cpu = find_idlest_cpu(group, t, cpu, tmpmask);
 		if (new_cpu == -1 || new_cpu == cpu) {
 			/* Now try balancing at a lower domain level of cpu */
 			sd = sd->child;
@@ -2182,7 +2192,7 @@ static int sched_balance_self(int cpu, i
 		/* Now try balancing at a lower domain level of new_cpu */
 		cpu = new_cpu;
 		sd = NULL;
-		weight = cpus_weight(span);
+		weight = cpus_weight(*span);
 		for_each_domain(cpu, tmp) {
 			if (weight <= cpus_weight(tmp->span))
 				break;
@@ -2192,6 +2202,9 @@ static int sched_balance_self(int cpu, i
 		/* while loop will break here if sd == NULL */
 	}
 
+	put_cpumask_var(span, temp_cpumask_1);
+	put_cpumask_var(tmpmask, temp_cpumask_2);
+
 	return cpu;
 }
 
@@ -3865,8 +3878,9 @@ static void rebalance_domains(int cpu, e
 	unsigned long next_balance = jiffies + 60*HZ;
 	int update_next_balance = 0;
 	int need_serialize;
-	cpumask_t tmp;
+	cpumask_ptr tmp;
 
+	get_cpumask_var(tmp, temp_cpumask_1);
 	for_each_domain(cpu, sd) {
 		if (!(sd->flags & SD_LOAD_BALANCE))
 			continue;
@@ -3890,7 +3904,7 @@ static void rebalance_domains(int cpu, e
 		}
 
 		if (time_after_eq(jiffies, sd->last_balance + interval)) {
-			if (load_balance(cpu, rq, sd, idle, &balance, &tmp)) {
+			if (load_balance(cpu, rq, sd, idle, &balance, tmp)) {
 				/*
 				 * We've pulled tasks over so either we're no
 				 * longer idle, or one of our SMT siblings is
@@ -3924,6 +3938,8 @@ out:
 	 */
 	if (likely(update_next_balance))
 		rq->next_balance = next_balance;
+
+	put_cpumask_var(tmp, temp_cpumask_1);
 }
 
 /*
@@ -5384,11 +5400,14 @@ out_unlock:
 
 long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
 {
-	cpumask_t cpus_allowed;
-	cpumask_t new_mask = *in_mask;
+	cpumask_ptr cpus_allowed;
+	cpumask_ptr new_mask;
 	struct task_struct *p;
 	int retval;
 
+	get_cpumask_var(cpus_allowed, temp_cpumask_1);
+	get_cpumask_var(new_mask, temp_cpumask_2);
+	*new_mask = *in_mask;
 	get_online_cpus();
 	read_lock(&tasklist_lock);
 
@@ -5416,24 +5435,26 @@ long sched_setaffinity(pid_t pid, const 
 	if (retval)
 		goto out_unlock;
 
-	cpuset_cpus_allowed(p, &cpus_allowed);
-	cpus_and(new_mask, new_mask, cpus_allowed);
+	cpuset_cpus_allowed(p, cpus_allowed);
+	cpus_and(*new_mask, *new_mask, *cpus_allowed);
  again:
-	retval = set_cpus_allowed_ptr(p, &new_mask);
+	retval = set_cpus_allowed_ptr(p, new_mask);
 
 	if (!retval) {
-		cpuset_cpus_allowed(p, &cpus_allowed);
-		if (!cpus_subset(new_mask, cpus_allowed)) {
+		cpuset_cpus_allowed(p, cpus_allowed);
+		if (!cpus_subset(*new_mask, *cpus_allowed)) {
 			/*
 			 * We must have raced with a concurrent cpuset
 			 * update. Just reset the cpus_allowed to the
 			 * cpuset's cpus_allowed
 			 */
-			new_mask = cpus_allowed;
+			*new_mask = *cpus_allowed;
 			goto again;
 		}
 	}
 out_unlock:
+	put_cpumask_var(cpus_allowed, temp_cpumask_1);
+	put_cpumask_var(new_mask, temp_cpumask_2);
 	put_task_struct(p);
 	put_online_cpus();
 	return retval;
@@ -6107,15 +6128,19 @@ static int __migrate_task_irq(struct tas
 static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
 {
 	unsigned long flags;
-	cpumask_t mask;
+	cpumask_ptr mask;
+	cpumask_ptr cpus_allowed;
 	struct rq *rq;
 	int dest_cpu;
 
+	get_cpumask_var(mask, temp_cpumask_1);
+	get_cpumask_var(cpus_allowed, temp_cpumask_2);
 	do {
 		/* On same node? */
-		mask = node_to_cpumask(cpu_to_node(dead_cpu));
-		cpus_and(mask, mask, p->cpus_allowed);
-		dest_cpu = any_online_cpu(mask);
+		node_to_cpumask_ptr(pnodemask, cpu_to_node(dead_cpu));
+		*mask = *pnodemask;
+		cpus_and(*mask, *mask, p->cpus_allowed);
+		dest_cpu = any_online_cpu(*mask);
 
 		/* On any allowed CPU? */
 		if (dest_cpu >= nr_cpu_ids)
@@ -6123,9 +6148,8 @@ static void move_task_off_dead_cpu(int d
 
 		/* No more Mr. Nice Guy. */
 		if (dest_cpu >= nr_cpu_ids) {
-			cpumask_t cpus_allowed;
+			cpuset_cpus_allowed_locked(p, cpus_allowed);
 
-			cpuset_cpus_allowed_locked(p, &cpus_allowed);
 			/*
 			 * Try to stay on the same cpuset, where the
 			 * current cpuset may be a subset of all cpus.
@@ -6134,7 +6158,7 @@ static void move_task_off_dead_cpu(int d
 			 * called within calls to cpuset_lock/cpuset_unlock.
 			 */
 			rq = task_rq_lock(p, &flags);
-			p->cpus_allowed = cpus_allowed;
+			p->cpus_allowed = *cpus_allowed;
 			dest_cpu = any_online_cpu(p->cpus_allowed);
 			task_rq_unlock(rq, &flags);
 
@@ -6150,6 +6174,9 @@ static void move_task_off_dead_cpu(int d
 			}
 		}
 	} while (!__migrate_task_irq(p, dead_cpu, dest_cpu));
+
+	put_cpumask_var(mask, temp_cpumask_1);
+	put_cpumask_var(cpus_allowed, temp_cpumask_2);
 }
 
 /*
@@ -6710,7 +6737,7 @@ static int sched_domain_debug_one(struct
 
 static void sched_domain_debug(struct sched_domain *sd, int cpu)
 {
-	cpumask_t *groupmask;
+	cpumask_ptr groupmask;
 	int level = 0;
 
 	if (!sd) {
@@ -6720,7 +6747,7 @@ static void sched_domain_debug(struct sc
 
 	printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
 
-	groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
+	alloc_cpumask_ptr(&groupmask);
 	if (!groupmask) {
 		printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
 		return;
@@ -6734,7 +6761,7 @@ static void sched_domain_debug(struct sc
 		if (!sd)
 			break;
 	}
-	kfree(groupmask);
+	free_cpumask_ptr(groupmask);
 }
 #else /* !CONFIG_SCHED_DEBUG */
 # define sched_domain_debug(sd, cpu) do { } while (0)
@@ -7120,9 +7147,9 @@ static int cpu_to_allnodes_group(int cpu
 				 struct sched_group **sg, cpumask_t *nodemask)
 {
 	int group;
+	node_to_cpumask_ptr(pnodemask, cpu_to_node(cpu));
 
-	*nodemask = node_to_cpumask(cpu_to_node(cpu));
-	cpus_and(*nodemask, *nodemask, *cpu_map);
+	cpus_and(*nodemask, *pnodemask, *cpu_map);
 	group = first_cpu(*nodemask);
 
 	if (sg)
@@ -7172,9 +7199,9 @@ static void free_sched_groups(const cpum
 
 		for (i = 0; i < nr_node_ids; i++) {
 			struct sched_group *oldsg, *sg = sched_group_nodes[i];
+			node_to_cpumask_ptr(pnodemask, i);
 
-			*nodemask = node_to_cpumask(i);
-			cpus_and(*nodemask, *nodemask, *cpu_map);
+			cpus_and(*nodemask, *pnodemask, *cpu_map);
 			if (cpus_empty(*nodemask))
 				continue;
 
@@ -7297,19 +7324,6 @@ struct allmasks {
 #endif
 };
 
-#if	NR_CPUS > 128
-#define	SCHED_CPUMASK_ALLOC		1
-#define	SCHED_CPUMASK_FREE(v)		kfree(v)
-#define	SCHED_CPUMASK_DECLARE(v)	struct allmasks *v
-#else
-#define	SCHED_CPUMASK_ALLOC		0
-#define	SCHED_CPUMASK_FREE(v)
-#define	SCHED_CPUMASK_DECLARE(v)	struct allmasks _v, *v = &_v
-#endif
-
-#define	SCHED_CPUMASK_VAR(v, a) 	cpumask_t *v = (cpumask_t *) \
-			((unsigned long)(a) + offsetof(struct allmasks, v))
-
 static int default_relax_domain_level = -1;
 
 static int __init setup_relax_domain_level(char *str)
@@ -7354,8 +7368,9 @@ static int __build_sched_domains(const c
 {
 	int i;
 	struct root_domain *rd;
-	SCHED_CPUMASK_DECLARE(allmasks);
-	cpumask_t *tmpmask;
+	CPUMASK_ALLOC(allmasks);
+	CPUMASK_PTR(tmpmask, allmasks);
+
 #ifdef CONFIG_NUMA
 	struct sched_group **sched_group_nodes = NULL;
 	int sd_allnodes = 0;
@@ -7367,6 +7382,7 @@ static int __build_sched_domains(const c
 				    GFP_KERNEL);
 	if (!sched_group_nodes) {
 		printk(KERN_WARNING "Can not alloc sched group node list\n");
+		CPUMASK_FREE(allmasks);
 		return -ENOMEM;
 	}
 #endif
@@ -7377,13 +7393,11 @@ static int __build_sched_domains(const c
 #ifdef CONFIG_NUMA
 		kfree(sched_group_nodes);
 #endif
+		CPUMASK_FREE(allmasks);
 		return -ENOMEM;
 	}
 
-#if SCHED_CPUMASK_ALLOC
-	/* get space for all scratch cpumask variables */
-	allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
-	if (!allmasks) {
+	if (allmasks == NULL) {
 		printk(KERN_WARNING "Cannot alloc cpumask array\n");
 		kfree(rd);
 #ifdef CONFIG_NUMA
@@ -7391,9 +7405,6 @@ static int __build_sched_domains(const c
 #endif
 		return -ENOMEM;
 	}
-#endif
-	tmpmask = (cpumask_t *)allmasks;
-
 
 #ifdef CONFIG_NUMA
 	sched_group_nodes_bycpu[first_cpu(*cpu_map)] = sched_group_nodes;
@@ -7404,10 +7415,10 @@ static int __build_sched_domains(const c
 	 */
 	for_each_cpu_mask_nr(i, *cpu_map) {
 		struct sched_domain *sd = NULL, *p;
-		SCHED_CPUMASK_VAR(nodemask, allmasks);
+		CPUMASK_PTR(nodemask, allmasks);
+		node_to_cpumask_ptr(pnodemask, cpu_to_node(i));
 
-		*nodemask = node_to_cpumask(cpu_to_node(i));
-		cpus_and(*nodemask, *nodemask, *cpu_map);
+		cpus_and(*nodemask, *pnodemask, *cpu_map);
 
 #ifdef CONFIG_NUMA
 		if (cpus_weight(*cpu_map) >
@@ -7470,8 +7481,8 @@ static int __build_sched_domains(const c
 #ifdef CONFIG_SCHED_SMT
 	/* Set up CPU (sibling) groups */
 	for_each_cpu_mask_nr(i, *cpu_map) {
-		SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
-		SCHED_CPUMASK_VAR(send_covered, allmasks);
+		CPUMASK_PTR(this_sibling_map, allmasks);
+		CPUMASK_PTR(send_covered, allmasks);
 
 		*this_sibling_map = per_cpu(cpu_sibling_map, i);
 		cpus_and(*this_sibling_map, *this_sibling_map, *cpu_map);
@@ -7487,8 +7498,8 @@ static int __build_sched_domains(const c
 #ifdef CONFIG_SCHED_MC
 	/* Set up multi-core groups */
 	for_each_cpu_mask_nr(i, *cpu_map) {
-		SCHED_CPUMASK_VAR(this_core_map, allmasks);
-		SCHED_CPUMASK_VAR(send_covered, allmasks);
+		CPUMASK_PTR(this_core_map, allmasks);
+		CPUMASK_PTR(send_covered, allmasks);
 
 		*this_core_map = cpu_coregroup_map(i);
 		cpus_and(*this_core_map, *this_core_map, *cpu_map);
@@ -7503,11 +7514,11 @@ static int __build_sched_domains(const c
 
 	/* Set up physical groups */
 	for (i = 0; i < nr_node_ids; i++) {
-		SCHED_CPUMASK_VAR(nodemask, allmasks);
-		SCHED_CPUMASK_VAR(send_covered, allmasks);
+		CPUMASK_PTR(nodemask, allmasks);
+		CPUMASK_PTR(send_covered, allmasks);
+		node_to_cpumask_ptr(pnodemask, i);
 
-		*nodemask = node_to_cpumask(i);
-		cpus_and(*nodemask, *nodemask, *cpu_map);
+		cpus_and(*nodemask, *pnodemask, *cpu_map);
 		if (cpus_empty(*nodemask))
 			continue;
 
@@ -7519,7 +7530,7 @@ static int __build_sched_domains(const c
 #ifdef CONFIG_NUMA
 	/* Set up node groups */
 	if (sd_allnodes) {
-		SCHED_CPUMASK_VAR(send_covered, allmasks);
+		CPUMASK_PTR(send_covered, allmasks);
 
 		init_sched_build_groups(cpu_map, cpu_map,
 					&cpu_to_allnodes_group,
@@ -7529,15 +7540,15 @@ static int __build_sched_domains(const c
 	for (i = 0; i < nr_node_ids; i++) {
 		/* Set up node groups */
 		struct sched_group *sg, *prev;
-		SCHED_CPUMASK_VAR(nodemask, allmasks);
-		SCHED_CPUMASK_VAR(domainspan, allmasks);
-		SCHED_CPUMASK_VAR(covered, allmasks);
+		CPUMASK_PTR(nodemask, allmasks);
+		CPUMASK_PTR(domainspan, allmasks);
+		CPUMASK_PTR(covered, allmasks);
+		node_to_cpumask_ptr(pnodemask, i);
 		int j;
 
-		*nodemask = node_to_cpumask(i);
 		cpus_clear(*covered);
 
-		cpus_and(*nodemask, *nodemask, *cpu_map);
+		cpus_and(*nodemask, *pnodemask, *cpu_map);
 		if (cpus_empty(*nodemask)) {
 			sched_group_nodes[i] = NULL;
 			continue;
@@ -7566,7 +7577,7 @@ static int __build_sched_domains(const c
 		prev = sg;
 
 		for (j = 0; j < nr_node_ids; j++) {
-			SCHED_CPUMASK_VAR(notcovered, allmasks);
+			CPUMASK_PTR(notcovered, allmasks);
 			int n = (i + j) % nr_node_ids;
 			node_to_cpumask_ptr(pnodemask, n);
 
@@ -7645,13 +7656,13 @@ static int __build_sched_domains(const c
 		cpu_attach_domain(sd, rd, i);
 	}
 
-	SCHED_CPUMASK_FREE((void *)allmasks);
+	CPUMASK_FREE(allmasks);
 	return 0;
 
 #ifdef CONFIG_NUMA
 error:
 	free_sched_groups(cpu_map, tmpmask);
-	SCHED_CPUMASK_FREE((void *)allmasks);
+	CPUMASK_FREE(allmasks);
 	return -ENOMEM;
 #endif
 }

-- 

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Peter Zijlstra]

On Sat, 2008-09-06 at 16:50 -0700, Mike Travis wrote:
> plain text document attachment (stack-hogs-kernel_sched_c)
> * Make the following changes to kernel/sched.c functions:
> 
>     - use node_to_cpumask_ptr in place of node_to_cpumask
>     - use get_cpumask_var for temporary cpumask_t variables
>     - use alloc_cpumask_ptr where available
> 
>   * Remove special code for SCHED_CPUMASK_ALLOC and use CPUMASK_ALLOC
>     from linux/cpumask.h.
> 
>   * The resultant stack savings are:
> 
>     ====== Stack (-l 100)
> 
> 	1 - initial
> 	2 - stack-hogs-kernel_sched_c
> 	'.' is less than the limit(100)
> 
>        .1.    .2.    ..final..
>       2216  -1536 680   -69%  __build_sched_domains
>       1592  -1592   .  -100%  move_task_off_dead_cpu
>       1096  -1096   .  -100%  sched_balance_self
>       1032  -1032   .  -100%  sched_setaffinity
>        616   -616   .  -100%  rebalance_domains
>        552   -552   .  -100%  free_sched_groups
>        512   -512   .  -100%  cpu_to_allnodes_group
>       7616  -6936 680   -91%  Totals
> 
> 
> Applies to linux-2.6.tip/master.
> 
> Signed-off-by: Mike Travis <travis@sgi.com>
> ---
>  kernel/sched.c |  151 ++++++++++++++++++++++++++++++---------------------------
>  1 file changed, 81 insertions(+), 70 deletions(-)
> 
> --- linux-2.6.tip.orig/kernel/sched.c
> +++ linux-2.6.tip/kernel/sched.c
> @@ -70,6 +70,7 @@
>  #include <linux/bootmem.h>
>  #include <linux/debugfs.h>
>  #include <linux/ctype.h>
> +#include <linux/cpumask_ptr.h>
>  #include <linux/ftrace.h>
>  #include <trace/sched.h>
>  
> @@ -117,6 +118,12 @@
>   */
>  #define RUNTIME_INF	((u64)~0ULL)
>  
> +/*
> + * temp cpumask variables
> + */
> +static DEFINE_PER_CPUMASK(temp_cpumask_1);
> +static DEFINE_PER_CPUMASK(temp_cpumask_2);

Yuck, that relies on turning preemption off everywhere you want to use
those.


> @@ -5384,11 +5400,14 @@ out_unlock:
>  
>  long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
>  {
> -	cpumask_t cpus_allowed;
> -	cpumask_t new_mask = *in_mask;
> +	cpumask_ptr cpus_allowed;
> +	cpumask_ptr new_mask;
>  	struct task_struct *p;
>  	int retval;
>  
> +	get_cpumask_var(cpus_allowed, temp_cpumask_1);
> +	get_cpumask_var(new_mask, temp_cpumask_2);
> +	*new_mask = *in_mask;
>  	get_online_cpus();
>  	read_lock(&tasklist_lock);

BUG!

get_online_cpus() can sleep, but you just disabled preemption with those
get_cpumask_var() horribles!

Couldn't be arsed to look through the rest, but I really hate this
cpumask_ptr() stuff that relies on disabling preemption.

NAK

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Andrew Morton]

On Sun, 07 Sep 2008 12:24:47 +0200 Peter Zijlstra <peterz@infradead.org> wrote:

> get_online_cpus() can sleep, but you just disabled preemption with those
> get_cpumask_var() horribles!

make cpu_hotplug.refcount an atomic_t.

> Couldn't be arsed to look through the rest, but I really hate this
> cpumask_ptr() stuff that relies on disabling preemption.

that's harder to fix ;)

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Peter Zijlstra]

On Sun, 2008-09-07 at 04:00 -0700, Andrew Morton wrote:
> On Sun, 07 Sep 2008 12:24:47 +0200 Peter Zijlstra <peterz@infradead.org> wrote:
> 
> > get_online_cpus() can sleep, but you just disabled preemption with those
> > get_cpumask_var() horribles!
> 
> make cpu_hotplug.refcount an atomic_t.

A much easier fix is just re-ordering those operations and do the
get_online_cpus() before disabling preemption. But it does indicate this
patch series isn't carefully constructed.

> > Couldn't be arsed to look through the rest, but I really hate this
> > cpumask_ptr() stuff that relies on disabling preemption.
> 
> that's harder to fix ;)

Looking at more patches than just the sched one convinced me more that
this approach isn't a good one. It seems to make code much more
fragile. 

See patch 9, there it was needed to draw out the callgraph in order to
map stuff to these global variables - we're adding global dependencies
to code that didn't have any, increasing complexity.

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Mike Travis]

Peter Zijlstra wrote:
> On Sun, 2008-09-07 at 04:00 -0700, Andrew Morton wrote:
>> On Sun, 07 Sep 2008 12:24:47 +0200 Peter Zijlstra <peterz@infradead.org> wrote:
>>
>>> get_online_cpus() can sleep, but you just disabled preemption with those
>>> get_cpumask_var() horribles!
>> make cpu_hotplug.refcount an atomic_t.
> 
> A much easier fix is just re-ordering those operations and do the
> get_online_cpus() before disabling preemption. But it does indicate this
> patch series isn't carefully constructed.

Yes, it's mostly a hunt for comments on my part... ;-)
> 
>>> Couldn't be arsed to look through the rest, but I really hate this
>>> cpumask_ptr() stuff that relies on disabling preemption.
>> that's harder to fix ;)
> 
> Looking at more patches than just the sched one convinced me more that
> this approach isn't a good one. It seems to make code much more
> fragile. 
> 
> See patch 9, there it was needed to draw out the callgraph in order to
> map stuff to these global variables - we're adding global dependencies
> to code that didn't have any, increasing complexity.

Again, yes, as I got farther into that one, it became clear that having
static cpumask_t temps over too large a range was ending up very messy.

Thanks,
Mike

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Peter Zijlstra]

On Sun, 2008-09-07 at 04:00 -0700, Andrew Morton wrote:

> make cpu_hotplug.refcount an atomic_t.

That might actually be a worthwhile idea, but it will not make
get_online_cpus() atomic. The whole point of get_online_cpus() is to
serialize against actual hotplug operations, so it will have to sleep at
some point.

Now, turning cpu_hotplug.refcount into an atomic_t might be worthwhile
because it will reduce the amount of atomic operations in its fastpath
from 2 to 1.

You'd have to make recount==1 the stable situation and use
atomic_inc_unless() and atomic_dec_and_test() in get_online_cpus() and
put_online_cpus() resp. that way !refcount can signify a hotplug
operation and we'd fall back into the slow paths.

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Mike Travis]

Peter Zijlstra wrote:
> On Sat, 2008-09-06 at 16:50 -0700, Mike Travis wrote:
>> plain text document attachment (stack-hogs-kernel_sched_c)
>> * Make the following changes to kernel/sched.c functions:
>>
>>     - use node_to_cpumask_ptr in place of node_to_cpumask
>>     - use get_cpumask_var for temporary cpumask_t variables
>>     - use alloc_cpumask_ptr where available
>>
>>   * Remove special code for SCHED_CPUMASK_ALLOC and use CPUMASK_ALLOC
>>     from linux/cpumask.h.
>>
>>   * The resultant stack savings are:
>>
>>     ====== Stack (-l 100)
>>
>> 	1 - initial
>> 	2 - stack-hogs-kernel_sched_c
>> 	'.' is less than the limit(100)
>>
>>        .1.    .2.    ..final..
>>       2216  -1536 680   -69%  __build_sched_domains
>>       1592  -1592   .  -100%  move_task_off_dead_cpu
>>       1096  -1096   .  -100%  sched_balance_self
>>       1032  -1032   .  -100%  sched_setaffinity
>>        616   -616   .  -100%  rebalance_domains
>>        552   -552   .  -100%  free_sched_groups
>>        512   -512   .  -100%  cpu_to_allnodes_group
>>       7616  -6936 680   -91%  Totals
>>
>>
>> Applies to linux-2.6.tip/master.
>>
>> Signed-off-by: Mike Travis <travis@sgi.com>
>> ---
>>  kernel/sched.c |  151 ++++++++++++++++++++++++++++++---------------------------
>>  1 file changed, 81 insertions(+), 70 deletions(-)
>>
>> --- linux-2.6.tip.orig/kernel/sched.c
>> +++ linux-2.6.tip/kernel/sched.c
>> @@ -70,6 +70,7 @@
>>  #include <linux/bootmem.h>
>>  #include <linux/debugfs.h>
>>  #include <linux/ctype.h>
>> +#include <linux/cpumask_ptr.h>
>>  #include <linux/ftrace.h>
>>  #include <trace/sched.h>
>>  
>> @@ -117,6 +118,12 @@
>>   */
>>  #define RUNTIME_INF	((u64)~0ULL)
>>  
>> +/*
>> + * temp cpumask variables
>> + */
>> +static DEFINE_PER_CPUMASK(temp_cpumask_1);
>> +static DEFINE_PER_CPUMASK(temp_cpumask_2);
> 
> Yuck, that relies on turning preemption off everywhere you want to use
> those.
> 
> 
>> @@ -5384,11 +5400,14 @@ out_unlock:
>>  
>>  long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
>>  {
>> -	cpumask_t cpus_allowed;
>> -	cpumask_t new_mask = *in_mask;
>> +	cpumask_ptr cpus_allowed;
>> +	cpumask_ptr new_mask;
>>  	struct task_struct *p;
>>  	int retval;
>>  
>> +	get_cpumask_var(cpus_allowed, temp_cpumask_1);
>> +	get_cpumask_var(new_mask, temp_cpumask_2);
>> +	*new_mask = *in_mask;
>>  	get_online_cpus();
>>  	read_lock(&tasklist_lock);
> 
> BUG!
> 
> get_online_cpus() can sleep, but you just disabled preemption with those
> get_cpumask_var() horribles!
> 
> Couldn't be arsed to look through the rest, but I really hate this
> cpumask_ptr() stuff that relies on disabling preemption.
> 
> NAK

Yeah, I really agree as well.  But I wanted to start playing with using
cpumask_t pointers in some fairly straight forward manner.  Linus's and
Ingo's suggestion to just bite the bullet and redefine the cpumask_t 
would force a lot of changes to be made, but perhaps that's really the
way to go.

As to obtaining temp cpumask_t's (both early and late), perhaps a pool of
them would be better?  I believe it could be done similar to alloc_bootmem
(but much simpler), and I don't think there's enough nesting to require a
very large pool.  (4 was the largest depth I could find in io_apic.c.)  Of
course, with preemption enabled then other problems arise...

One other really big use was for the "allbutself" cpumask in the send_IPI
functions.  I think here, preemption is ok because the ownership of the
cpumask temp is very short lived.

But thanks for pointing out the get_online_cpus problem.  I did try and
chase down as many call trees as I could, but I obviously missed one
important one.

And thanks for looking it over!
Mike

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Peter Zijlstra]

On Mon, 2008-09-08 at 07:54 -0700, Mike Travis wrote:
> Peter Zijlstra wrote:

> > get_online_cpus() can sleep, but you just disabled preemption with those
> > get_cpumask_var() horribles!
> > 
> > Couldn't be arsed to look through the rest, but I really hate this
> > cpumask_ptr() stuff that relies on disabling preemption.
> > 
> > NAK
> 
> Yeah, I really agree as well.  But I wanted to start playing with using
> cpumask_t pointers in some fairly straight forward manner.  Linus's and
> Ingo's suggestion to just bite the bullet and redefine the cpumask_t 
> would force a lot of changes to be made, but perhaps that's really the
> way to go.

I much prefer that approach!

> As to obtaining temp cpumask_t's (both early and late), perhaps a pool of
> them would be better?  I believe it could be done similar to alloc_bootmem
> (but much simpler), and I don't think there's enough nesting to require a
> very large pool.  (4 was the largest depth I could find in io_apic.c.)  Of
> course, with preemption enabled then other problems arise...
> 
> One other really big use was for the "allbutself" cpumask in the send_IPI
> functions.  I think here, preemption is ok because the ownership of the
> cpumask temp is very short lived.

The thing is, you add serialization requirements (be it preempt_disable,
or a lock for some preemptable form) to code that didn't had any for a
case that hardly anyone will ever encounter in real life - I mean,
really, who has 4096 cpus?

Stuffing the cpumap_t in an already existing structure that has suitable
serialization requirements is of course the preferred situation, but
lacking that a dynamic cpumap_t is best, since it keeps the references
local, and thus doesn't add requirements to the existing code.

You could also consider adding 1 cpumap_t to task_struct and use that as
temporary scratch pad - but seeing you needed at least 4 that might not
be a feasible solution either.

Re: [RFC 07/13] sched: Reduce stack size requirements in kernel/sched.c

[Ingo Molnar]

* Peter Zijlstra <peterz@infradead.org> wrote:

> > > NAK
> > 
> > Yeah, I really agree as well.  But I wanted to start playing with 
> > using cpumask_t pointers in some fairly straight forward manner.  
> > Linus's and Ingo's suggestion to just bite the bullet and redefine 
> > the cpumask_t would force a lot of changes to be made, but perhaps 
> > that's really the way to go.
> 
> I much prefer that approach!

seconded. Mike, since none of this is v2.6.27 material, lets do it right 
with a v2.6.28 target. You know all the cpumask_t using code sites 
inside out already, so the know-how is all available already :-) Please 
make it finegrained series of patches so that we can resolve conflicts 
with other trees more easily.

perhaps propose the new cpumask_t API early (in this thread?), so that 
people can comment on it before NAKs come flying against a full patchset 
;-)

	Ingo

[RFC] CPUMASK: proposal for replacing cpumask_t

[Mike Travis]

Ingo Molnar wrote:
> * Peter Zijlstra <peterz@infradead.org> wrote:
> 
>>>> NAK
...
> 
> seconded. Mike, since none of this is v2.6.27 material, lets do it right 
> with a v2.6.28 target. You know all the cpumask_t using code sites 
> inside out already, so the know-how is all available already :-) Please 
> make it finegrained series of patches so that we can resolve conflicts 
> with other trees more easily.
> 
> perhaps propose the new cpumask_t API early (in this thread?), so that 
> people can comment on it before NAKs come flying against a full patchset 
> ;-)
> 
> 	Ingo


Here's an initial proposal for abstracting cpumask_t to be either
an array of 1 or a pointer to an array...   Hopefully this will
minimize the amount of code changes while providing the capabilities
this change is attempting to do.

Comments most welcome. ;-)

Thanks,
Mike
--

Basically, linux/cpumask.h has the following defines:

	typedef struct { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_data;

	#if NR_CPUS > BITS_PER_LONG
	typedef const cpumask_data	*cpumask_t;
	typedef cpumask_data		*cpumask_var;
	typedef cpumask_t		cpumask_val;
	#define	_NR_CPUS		nr_cpu_ids
	#else
	typedef const cpumask_data	cpumask_t[1];
	typedef cpumask_data		cpumask_var[1];
	typedef cpumask_data		cpumask_val;
	#define	_NR_CPUS		NR_CPUS
	#endif

So in function prototypes:

	cpumask_t function(const cpumask_t *A,
			   cpumask_t *B,
			   cpumask_t cpumask_C)

becomes:

	cpumask_val function(cpumask_t A,
			     cpumask_var B,
			     cpumask_t cpumask_C)

And in local variables:

	cpumask_t ==> cpumask_var  IFF variable is to be written.

This:

	cpumask_t mask = cpu_online_map 
	<change mask>

becomes:

	#include <linux/cpumask_alloc.h>

	cpumask_var mask;

	alloc_cpumask(&mask);
	*mask = *cpu_online_map;
	<change mask>
	free_cpumask(&mask);

Currently, alloc_cpumask is:

	#define BYTES_PER_CPUMASK (BITS_TO_LONGS(nr_cpu_ids)/sizeof(long))

	static inline bool no_cpumask(cpumask_t *m)
	{
		return (*m == NULL);
	}

	static inline void alloc_cpumask(cpumask_t *m)
	{
		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);
		if (no_cpumask(&d))
			BUG();
		*m = d;
	}

	static inline void alloc_cpumask_nopanic(cpumask_t *m)
	{
		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);

		*m = d;
	}

	static inline void free_cpumask(cpumask_t *m)
	{
		kfree(*m);
	}

Other means of obtaining a temporary cpumask_t variable will be provided
for those cases where kmalloc() is not available.

Furthermore, system-wide maps become:

	extern cpumask_data _cpu_possible_map;			 /* read/write */
	extern cpumask_data _cpu_online_map;
	extern cpumask_data _cpu_present_map;
	extern cpumask_data _cpu_active_map;
	#define	cpu_possible_map ((cpumask_t)&_cpu_possible_map) /* read only */
	#define	cpu_online_map ((cpumask_t)&_cpu_online_map)
	#define	cpu_present_map ((cpumask_t)&_cpu_present_map)
	#define	cpu_active_map ((cpumask_t)&_cpu_active_map)


So code to set these bits would be:

	cpu_set(cpu, &_cpu_online_map);
	cpu_set(cpu, &_cpu_present_map);
	cpu_set(cpu, &_cpu_possible_map);

Arrays that contain a fixed cpumask would have:

	struct xxx {
		cpumask_data	cpumask;
	};

... though we should probably encourage the map to be allocated:

	struct xxx {
		cpumask_t	readonly_cpumask;
		cpumask_var	readwrite_cpumask;
	};

	alloc_cpumask(&xxx->readonly_cpumask);
	alloc_cpumask(&xxx->readwrite_cpumask);


All the cpu operators become:

	#define cpu_XXX(dst, src) _cpu_XXX(dst, src, _NR_CPUS)
	static inline void __cpu_XXX(cpumask_var dstp, cpumask_t srcp, int count)
	{
		XXX_bit(dstp->bits, srcp->bits, count);
	}

(_NR_CPUS being defined to be nr_cpu_ids allows us to allocate variable lengthed arrays.)


Cpumask initializers become:


	#if NR_CPUS <= BITS_PER_LONG

	#define INIT_CPU_MASK_ALL					\
	(cpumask_t) { {							\
		[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD		\
	} }

	#else
	#define INIT_CPU_MASK_ALL					\
	(cpumask_data) { {						\
		[0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL,		\
		[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD		\
	} }
	#endif

	#define INIT_CPU_MASK_NONE					\
	(cpumask_data) { {						\
		[0 ... BITS_TO_LONGS(NR_CPUS)-1] =  0UL			\
	} }

	#define INIT_CPU_MASK_CPU0					\
	(cpumask_data) { {						\
		[0] =  1UL						\
	} }

	#if NR_CPUS > BITS_PER_LONG
	extern cpumask_t cpu_mask_all, cpu_mask_none, cpu_mask_cpu0;
	#define CPU_MASK_ALL		(cpu_mask_all)
	#define CPU_MASK_NONE		(cpu_mask_none)
	#define CPU_MASK_CPU0		(cpu_mask_cpu0)
	#else
	#define CPU_MASK_ALL		((cpumask_t)&INIT_CPU_MASK_ALL)
	#define CPU_MASK_NONE		((cpumask_t)&INIT_CPU_MASK_NONE)
	#define CPU_MASK_CPU0		((cpumask_t)&INIT_CPU_MASK_CPU0)
	#endif

And in kernel/cpu.c:

	/*
	 * provide const cpumask_t's
	 */
	#if NR_CPUS > BITS_PER_LONG
	cpumask_data cpu_mask_all __read_mostly = INIT_CPU_MASK_ALL;
	EXPORT_SYMBOL(cpu_mask_all);

	cpumask_data cpu_mask_none __read_mostly = INIT_CPU_MASK_NONE;
	EXPORT_SYMBOL(cpu_mask_none);

	cpumask_data cpu_mask_cpu0 __read_mostly = INIT_CPU_MASK_CPU0;
	EXPORT_SYMBOL(cpu_mask_cpu0);
	#endif

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Andi Kleen]

> Here's an initial proposal for abstracting cpumask_t to be either

At least for some cases I don't think you'll get around defining
a "nearby subset of CPUs that can be handled together" type. Handling 1K 
objects all the time in one piece is simply not a good idea.

-Andi

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Mike Travis]

Andi Kleen wrote:
>> Here's an initial proposal for abstracting cpumask_t to be either
> 
> At least for some cases I don't think you'll get around defining
> a "nearby subset of CPUs that can be handled together" type. Handling 1K 
> objects all the time in one piece is simply not a good idea.
> 
> -Andi


Every time I stop to think about this, the problems with the cpu
operators come to mind.  Should there be a separate set?  Or simply
conversion functions to/from a "cpumask_subset" type?  

Thanks,
Mike

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Andi Kleen]

On Wed, Sep 10, 2008 at 04:33:16PM -0700, Mike Travis wrote:
> Andi Kleen wrote:
> >> Here's an initial proposal for abstracting cpumask_t to be either
> > 
> > At least for some cases I don't think you'll get around defining
> > a "nearby subset of CPUs that can be handled together" type. Handling 1K 
> > objects all the time in one piece is simply not a good idea.
> > 
> > -Andi
> 
> 
> Every time I stop to think about this, the problems with the cpu
> operators come to mind.  Should there be a separate set?  Or simply
> conversion functions to/from a "cpumask_subset" type?  

A subset would be hopefully enough (set/isset etc.) plus conversion
operators.

-Andi

-- 
ak@linux.intel.com

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Peter Zijlstra]

On Wed, 2008-09-10 at 15:47 -0700, Mike Travis wrote:
> Ingo Molnar wrote:
> > * Peter Zijlstra <peterz@infradead.org> wrote:
> > 
> >>>> NAK
> ....
> > 
> > seconded. Mike, since none of this is v2.6.27 material, lets do it right 
> > with a v2.6.28 target. You know all the cpumask_t using code sites 
> > inside out already, so the know-how is all available already :-) Please 
> > make it finegrained series of patches so that we can resolve conflicts 
> > with other trees more easily.
> > 
> > perhaps propose the new cpumask_t API early (in this thread?), so that 
> > people can comment on it before NAKs come flying against a full patchset 
> > ;-)
> > 
> > 	Ingo
> 
> 
> Here's an initial proposal for abstracting cpumask_t to be either
> an array of 1 or a pointer to an array...   Hopefully this will
> minimize the amount of code changes while providing the capabilities
> this change is attempting to do.
> 
> Comments most welcome. ;-)
> 
> Thanks,
> Mike
> --
> 
> Basically, linux/cpumask.h has the following defines:
> 
> 	typedef struct { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_data;
> 
> 	#if NR_CPUS > BITS_PER_LONG
> 	typedef const cpumask_data	*cpumask_t;
> 	typedef cpumask_data		*cpumask_var;
> 	typedef cpumask_t		cpumask_val;
> 	#define	_NR_CPUS		nr_cpu_ids
> 	#else
> 	typedef const cpumask_data	cpumask_t[1];
> 	typedef cpumask_data		cpumask_var[1];
> 	typedef cpumask_data		cpumask_val;
> 	#define	_NR_CPUS		NR_CPUS
> 	#endif
> 
> So in function prototypes:
> 
> 	cpumask_t function(const cpumask_t *A,
> 			   cpumask_t *B,
> 			   cpumask_t cpumask_C)
> 
> becomes:
> 
> 	cpumask_val function(cpumask_t A,
> 			     cpumask_var B,
> 			     cpumask_t cpumask_C)

I guess we have to stick the const into the typedef otherwise we get a
const pointer instead of a const array member, right?

In which case I much prefer the following names:

 cpumask_data_t  - value

 const_cpumask_t - pointer to constant value
 cpumask_t       - pointer to value

> And in local variables:
> 
> 	cpumask_t ==> cpumask_var  IFF variable is to be written.
> 
> This:
> 
> 	cpumask_t mask = cpu_online_map 
> 	<change mask>
> 
> becomes:
> 
> 	#include <linux/cpumask_alloc.h>
> 
> 	cpumask_var mask;
> 
> 	alloc_cpumask(&mask);

Don't you have to deal with allocation errors?

> 	*mask = *cpu_online_map;
> 	<change mask>
> 	free_cpumask(&mask);
> 
> Currently, alloc_cpumask is:
> 
> 	#define BYTES_PER_CPUMASK (BITS_TO_LONGS(nr_cpu_ids)/sizeof(long))
> 
> 	static inline bool no_cpumask(cpumask_t *m)
> 	{
> 		return (*m == NULL);
> 	}
> 
> 	static inline void alloc_cpumask(cpumask_t *m)
> 	{
> 		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);
> 		if (no_cpumask(&d))
> 			BUG();

yuckery yuck yuck!

> 		*m = d;
> 	}
> 
> 	static inline void alloc_cpumask_nopanic(cpumask_t *m)
> 	{
> 		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);
> 
> 		*m = d;
> 	}

gah - at the very least you got the naming wrong, methinks the one
panic-ing should have panic in its name - if you really want to persist
with that variant.

> 	static inline void free_cpumask(cpumask_t *m)
> 	{
> 		kfree(*m);
> 	}
> 
> Other means of obtaining a temporary cpumask_t variable will be provided
> for those cases where kmalloc() is not available.
> 
> Furthermore, system-wide maps become:
> 
> 	extern cpumask_data _cpu_possible_map;			 /* read/write */
> 	extern cpumask_data _cpu_online_map;
> 	extern cpumask_data _cpu_present_map;
> 	extern cpumask_data _cpu_active_map;
> 	#define	cpu_possible_map ((cpumask_t)&_cpu_possible_map) /* read only */
> 	#define	cpu_online_map ((cpumask_t)&_cpu_online_map)
> 	#define	cpu_present_map ((cpumask_t)&_cpu_present_map)
> 	#define	cpu_active_map ((cpumask_t)&_cpu_active_map)
> 
> 
> So code to set these bits would be:
> 
> 	cpu_set(cpu, &_cpu_online_map);
> 	cpu_set(cpu, &_cpu_present_map);
> 	cpu_set(cpu, &_cpu_possible_map);
> 
> Arrays that contain a fixed cpumask would have:
> 
> 	struct xxx {
> 		cpumask_data	cpumask;
> 	};
> 
> .... though we should probably encourage the map to be allocated:
> 
> 	struct xxx {
> 		cpumask_t	readonly_cpumask;
> 		cpumask_var	readwrite_cpumask;
> 	};
> 
> 	alloc_cpumask(&xxx->readonly_cpumask);
> 	alloc_cpumask(&xxx->readwrite_cpumask);
> 
> 
> All the cpu operators become:
> 
> 	#define cpu_XXX(dst, src) _cpu_XXX(dst, src, _NR_CPUS)
> 	static inline void __cpu_XXX(cpumask_var dstp, cpumask_t srcp, int count)
> 	{
> 		XXX_bit(dstp->bits, srcp->bits, count);
> 	}
> 
> (_NR_CPUS being defined to be nr_cpu_ids allows us to allocate variable lengthed arrays.)
> 
> 
> Cpumask initializers become:
> 
> 
> 	#if NR_CPUS <= BITS_PER_LONG
> 
> 	#define INIT_CPU_MASK_ALL					\
> 	(cpumask_t) { {							\
> 		[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD		\
> 	} }
> 
> 	#else
> 	#define INIT_CPU_MASK_ALL					\
> 	(cpumask_data) { {						\
> 		[0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL,		\
> 		[BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD		\
> 	} }
> 	#endif
> 
> 	#define INIT_CPU_MASK_NONE					\
> 	(cpumask_data) { {						\
> 		[0 ... BITS_TO_LONGS(NR_CPUS)-1] =  0UL			\
> 	} }
> 
> 	#define INIT_CPU_MASK_CPU0					\
> 	(cpumask_data) { {						\
> 		[0] =  1UL						\
> 	} }
> 
> 	#if NR_CPUS > BITS_PER_LONG
> 	extern cpumask_t cpu_mask_all, cpu_mask_none, cpu_mask_cpu0;
> 	#define CPU_MASK_ALL		(cpu_mask_all)
> 	#define CPU_MASK_NONE		(cpu_mask_none)
> 	#define CPU_MASK_CPU0		(cpu_mask_cpu0)
> 	#else
> 	#define CPU_MASK_ALL		((cpumask_t)&INIT_CPU_MASK_ALL)
> 	#define CPU_MASK_NONE		((cpumask_t)&INIT_CPU_MASK_NONE)
> 	#define CPU_MASK_CPU0		((cpumask_t)&INIT_CPU_MASK_CPU0)
> 	#endif
> 
> And in kernel/cpu.c:
> 
> 	/*
> 	 * provide const cpumask_t's
> 	 */
> 	#if NR_CPUS > BITS_PER_LONG
> 	cpumask_data cpu_mask_all __read_mostly = INIT_CPU_MASK_ALL;
> 	EXPORT_SYMBOL(cpu_mask_all);
> 
> 	cpumask_data cpu_mask_none __read_mostly = INIT_CPU_MASK_NONE;
> 	EXPORT_SYMBOL(cpu_mask_none);
> 
> 	cpumask_data cpu_mask_cpu0 __read_mostly = INIT_CPU_MASK_CPU0;
> 	EXPORT_SYMBOL(cpu_mask_cpu0);
> 	#endif
> 

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Mike Travis]

Peter Zijlstra wrote:
...
>> So in function prototypes:
>>
>> 	cpumask_t function(const cpumask_t *A,
>> 			   cpumask_t *B,
>> 			   cpumask_t cpumask_C)
>>
>> becomes:
>>
>> 	cpumask_val function(cpumask_t A,
>> 			     cpumask_var B,
>> 			     cpumask_t cpumask_C)
> 
> I guess we have to stick the const into the typedef otherwise we get a
> const pointer instead of a const array member, right?
> 
> In which case I much prefer the following names:
> 
>  cpumask_data_t  - value
> 
>  const_cpumask_t - pointer to constant value
>  cpumask_t       - pointer to value

There were some comments previously such that we should "imply" that the
incoming cpumask_t args are const, so the compiler would flag those
who arbitrarily modify it.

> 
...
>> 	alloc_cpumask(&mask);
> 
> Don't you have to deal with allocation errors?

In a perfect world, no... ;-)
...
>> 	static inline void alloc_cpumask(cpumask_t *m)
>> 	{
>> 		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);
>> 		if (no_cpumask(&d))
>> 			BUG();
> 
> yuckery yuck yuck!
> 
>> 		*m = d;
>> 	}
>>
>> 	static inline void alloc_cpumask_nopanic(cpumask_t *m)
>> 	{
>> 		cpumask_t d = kmalloc(BYTES_PER_CPUMASK, GFP_KERNEL);
>>
>> 		*m = d;
>> 	}
> 
> gah - at the very least you got the naming wrong, methinks the one
> panic-ing should have panic in its name - if you really want to persist
> with that variant.

Yeah, I rather rushed through the allocation part (yuck indeed ;-).

There are some other alternatives:

	- reserve one or more of these in the task struct
	- reserve one or more in a per-cpu area
	- setup some kind of allocation pool similar to alloc_bootmem
	- ???

Thanks,
Mike

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Rusty Russell]

On Thursday 11 September 2008 08:47:58 Mike Travis wrote:
> Here's an initial proposal for abstracting cpumask_t to be either
> an array of 1 or a pointer to an array...   Hopefully this will
> minimize the amount of code changes while providing the capabilities
> this change is attempting to do.
>
> Comments most welcome. ;-)

I think this is still "wrong way go back".

I'm yet to be convinced that we really need to allocate cpumasks in any fast 
paths.  And if not, we should simply allocate them everywhere.  I'd rather 
see one #ifdef around a place where we can show a perf issue.

Get rid of CPU_MASK_ALL et al in favour of cpu_mask_all.  And cpu_mask_any_one 
instead of CPU_MASK_CPU0 since that's usually what they want.

API looks like so (look Ma, no typedefs!)

	struct cpumask *cpus;

	cpus = cpumask_alloc();
	if (!cpus)
		return -ENOMEM;

	cpumask_init_single(cpunum);
	OR
	cpumask_init(cpu_mask_all);
	...
	cpumask_free(cpus);

Unmistakable and really hard to screw up.  You can even be clever and not 
reveal the struct cpumask definition so noone can declare one by accident...

Cheers,
Rusty.

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Mike Travis]

Rusty Russell wrote:
> On Thursday 11 September 2008 08:47:58 Mike Travis wrote:
>> Here's an initial proposal for abstracting cpumask_t to be either
>> an array of 1 or a pointer to an array...   Hopefully this will
>> minimize the amount of code changes while providing the capabilities
>> this change is attempting to do.
>>
>> Comments most welcome. ;-)
> 
> I think this is still "wrong way go back".
> 
> I'm yet to be convinced that we really need to allocate cpumasks in any fast 
> paths.  And if not, we should simply allocate them everywhere.  I'd rather 
> see one #ifdef around a place where we can show a perf issue.
> 
> Get rid of CPU_MASK_ALL et al in favour of cpu_mask_all.  And cpu_mask_any_one 
> instead of CPU_MASK_CPU0 since that's usually what they want.
> 
> API looks like so (look Ma, no typedefs!)
> 
> 	struct cpumask *cpus;
> 
> 	cpus = cpumask_alloc();
> 	if (!cpus)
> 		return -ENOMEM;
> 
> 	cpumask_init_single(cpunum);
> 	OR
> 	cpumask_init(cpu_mask_all);
> 	...
> 	cpumask_free(cpus);
> 
> Unmistakable and really hard to screw up.  You can even be clever and not 
> reveal the struct cpumask definition so noone can declare one by accident...
> 
> Cheers,
> Rusty.

Using a typedef came from Linus, and the idea is basically if NR_CPUS fits
into a long, then it's carried as an array of one (ie., local variable).
If it's bigger, then it's a pointer to a remote array.  The references can
all be pointers (*cpumask), though most of the references use the cpu_XXX
operators which already treat the references correctly (in my proposal,
that is).  That way, small systems can optimize out the indirect reference
and the overhead becomes zero.

Also, cpumask_alloc/free() becomes nop's for small systems.

But I like the idea of dumping some of the initializers.  I should have
made CPU0 "cpumask_of_cpu(0)".  I'll have to look at where they are used to
see if this is feasible.

Thanks!
Mike

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Rusty Russell]

On Saturday 13 September 2008 00:28:56 Mike Travis wrote:
> Rusty Russell wrote:
> > I'm yet to be convinced that we really need to allocate cpumasks in any
> > fast paths.  And if not, we should simply allocate them everywhere.  I'd
> > rather see one #ifdef around a place where we can show a perf issue.
>
> Using a typedef came from Linus, and the idea is basically if NR_CPUS fits
> into a long, then it's carried as an array of one (ie., local variable).

Sure it's clever.  ie. nice and confusing.

But do we have any code paths where we care?  Unless we do, let's just keep it 
simple...

Cheers,
Rusty.

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[Mike Travis]

Rusty Russell wrote:
> On Saturday 13 September 2008 00:28:56 Mike Travis wrote:
>> Rusty Russell wrote:
>>> I'm yet to be convinced that we really need to allocate cpumasks in any
>>> fast paths.  And if not, we should simply allocate them everywhere.  I'd
>>> rather see one #ifdef around a place where we can show a perf issue.
>> Using a typedef came from Linus, and the idea is basically if NR_CPUS fits
>> into a long, then it's carried as an array of one (ie., local variable).
> 
> Sure it's clever.  ie. nice and confusing.
> 
> But do we have any code paths where we care?  Unless we do, let's just keep it 
> simple...
> 
> Cheers,
> Rusty.

Here's the thread:

	http://marc.info/?l=linux-kernel&m=121976977901223&w=4

It doesn't seem worthwhile to force all systems to deal with large cpumask's
if they don't need to.  Passing the value on the stack (actually usually in a
reg) if it fits into a long makes a lot of sense.

And I don't think it's that abstract, but I'm willing to hear other opinions.

Btw, most likely only distros that distribute an "Enterprise" edition of
Linux will ever set NR_CPUS so high, so the actual number of systems making
use of this will be a very small percentage (big $$-wise though... ;-) 

I even think that perhaps BITS_PER_LONG might be too low a threshold to kick
in this extra code.  A Larabee chip will have 128 cpus so maybe 128 or 256 is
a better metric...?

As soon as I get a working kernel with the proposed changes, I will definitely
be doing perf testing.

Thanks,
Mike

Re: [RFC] CPUMASK: proposal for replacing cpumask_t

[H. Peter Anvin]

Mike Travis wrote:
> 
> Here's the thread:
> 
> 	http://marc.info/?l=linux-kernel&m=121976977901223&w=4
> 
> It doesn't seem worthwhile to force all systems to deal with large cpumask's
> if they don't need to.  Passing the value on the stack (actually usually in a
> reg) if it fits into a long makes a lot of sense.
> 
> And I don't think it's that abstract, but I'm willing to hear other opinions.
> 
> Btw, most likely only distros that distribute an "Enterprise" edition of
> Linux will ever set NR_CPUS so high, so the actual number of systems making
> use of this will be a very small percentage (big $$-wise though... ;-) 
> 
> I even think that perhaps BITS_PER_LONG might be too low a threshold to kick
> in this extra code.  A Larabee chip will have 128 cpus so maybe 128 or 256 is
> a better metric...?
> 
> As soon as I get a working kernel with the proposed changes, I will definitely
> be doing perf testing.
> 

If the performance difference isn't significant, then there is a major 
advantage to getting rid of a configuration option.  At that point we 
can basically scale to an arbitrary number of processors in a stock 
configuration.

	-hpa

[RFC 08/13] cpufreq: Reduce stack size requirements in acpi-cpufreq.c

[Mike Travis]

[-- Attachment #1: stack-hogs-acpi-cpufreq_c --]
[-- Type: text/plain, Size: 7299 bytes --]

  * Make the following changes to acpi-cpufreq.c functions:

    - use node_to_cpumask_ptr in place of node_to_cpumask
    - use get_cpumask_var for temporary cpumask_t variables
    - use alloc_cpumask_ptr where available
    - use a per_cpu temp variable for drv_cmd which contains an
	embedded cpumask_t variable.

  * The resultant stack savings are:

    ====== Stack (-l 100)

	1 - initial
	2 - stack-hogs-acpi-cpufreq_c
	'.' is less than the limit(100)

       .1.    .2.    ..final..
      1608  -1024 584   -63%  acpi_cpufreq_target
      1096  -1096   .  -100%  sched_balance_self
      1048   -536 512   -51%  get_cur_val
       520   -520   .  -100%  get_measured_perf

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c |   93 +++++++++++++++++------------
 1 file changed, 57 insertions(+), 36 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ linux-2.6.tip/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -33,6 +33,7 @@
 #include <linux/cpufreq.h>
 #include <linux/compiler.h>
 #include <linux/dmi.h>
+#include <linux/cpumask_ptr.h>
 
 #include <linux/acpi.h>
 #include <acpi/processor.h>
@@ -68,6 +69,8 @@ struct acpi_cpufreq_data {
 };
 
 static DEFINE_PER_CPU(struct acpi_cpufreq_data *, drv_data);
+static DEFINE_PER_CPU(struct drv_cmd, temp_cmd);
+static DEFINE_PER_CPUMASK(temp_cpumask);
 
 /* acpi_perf_data is a pointer to percpu data. */
 static struct acpi_processor_performance *acpi_perf_data;
@@ -214,33 +217,39 @@ static void drv_write(struct drv_cmd *cm
 static u32 get_cur_val(const cpumask_t *mask)
 {
 	struct acpi_processor_performance *perf;
-	struct drv_cmd cmd;
+	struct drv_cmd *cmd;
+	u32 temp_val;
 
 	if (unlikely(cpus_empty(*mask)))
 		return 0;
 
+	cmd = &get_cpu_var(temp_cmd);
 	switch (per_cpu(drv_data, first_cpu(*mask))->cpu_feature) {
 	case SYSTEM_INTEL_MSR_CAPABLE:
-		cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
-		cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
+		cmd->type = SYSTEM_INTEL_MSR_CAPABLE;
+		cmd->addr.msr.reg = MSR_IA32_PERF_STATUS;
 		break;
 	case SYSTEM_IO_CAPABLE:
-		cmd.type = SYSTEM_IO_CAPABLE;
+		cmd->type = SYSTEM_IO_CAPABLE;
 		perf = per_cpu(drv_data, first_cpu(*mask))->acpi_data;
-		cmd.addr.io.port = perf->control_register.address;
-		cmd.addr.io.bit_width = perf->control_register.bit_width;
+		cmd->addr.io.port = perf->control_register.address;
+		cmd->addr.io.bit_width = perf->control_register.bit_width;
 		break;
 	default:
+		put_cpu_var(temp_cmd);
 		return 0;
 	}
 
-	cmd.mask = *mask;
+	cmd->mask = *mask;
 
-	drv_read(&cmd);
+	drv_read(cmd);
 
-	dprintk("get_cur_val = %u\n", cmd.val);
+	temp_val = cmd->val;
+	put_cpu_var(temp_cmd);
 
-	return cmd.val;
+	dprintk("get_cur_val = %u\n", temp_val);
+
+	return temp_val;
 }
 
 /*
@@ -266,11 +275,12 @@ static unsigned int get_measured_perf(un
 		u64 whole;
 	} aperf_cur, mperf_cur;
 
-	cpumask_t saved_mask;
+	cpumask_ptr saved_mask;
 	unsigned int perf_percent;
 	unsigned int retval;
 
-	saved_mask = current->cpus_allowed;
+	get_cpumask_var(saved_mask, temp_cpumask);
+	*saved_mask = current->cpus_allowed;
 	set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
 	if (get_cpu() != cpu) {
 		/* We were not able to run on requested processor */
@@ -329,7 +339,8 @@ static unsigned int get_measured_perf(un
 	retval = per_cpu(drv_data, cpu)->max_freq * perf_percent / 100;
 
 	put_cpu();
-	set_cpus_allowed_ptr(current, &saved_mask);
+	set_cpus_allowed_ptr(current, saved_mask);
+	put_cpumask_var(saved_mask, temp_cpumask);
 
 	dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
 	return retval;
@@ -384,8 +395,8 @@ static int acpi_cpufreq_target(struct cp
 	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
 	struct acpi_processor_performance *perf;
 	struct cpufreq_freqs freqs;
-	cpumask_t online_policy_cpus;
-	struct drv_cmd cmd;
+	cpumask_ptr online_policy_cpus;
+	struct drv_cmd *cmd;
 	unsigned int next_state = 0; /* Index into freq_table */
 	unsigned int next_perf_state = 0; /* Index into perf table */
 	unsigned int i;
@@ -394,9 +405,8 @@ static int acpi_cpufreq_target(struct cp
 	dprintk("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);
 
 	if (unlikely(data == NULL ||
-	     data->acpi_data == NULL || data->freq_table == NULL)) {
+	     data->acpi_data == NULL || data->freq_table == NULL))
 		return -ENODEV;
-	}
 
 	perf = data->acpi_data;
 	result = cpufreq_frequency_table_target(policy,
@@ -406,11 +416,15 @@ static int acpi_cpufreq_target(struct cp
 	if (unlikely(result))
 		return -ENODEV;
 
+	/* obtain temp variables */
+	get_cpumask_var(online_policy_cpus, temp_cpumask);
+	cmd = &get_cpu_var(temp_cmd);
+
 #ifdef CONFIG_HOTPLUG_CPU
 	/* cpufreq holds the hotplug lock, so we are safe from here on */
-	cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
+	cpus_and(*online_policy_cpus, cpu_online_map, policy->cpus);
 #else
-	online_policy_cpus = policy->cpus;
+	*online_policy_cpus = policy->cpus;
 #endif
 
 	next_perf_state = data->freq_table[next_state].index;
@@ -422,56 +436,63 @@ static int acpi_cpufreq_target(struct cp
 		} else {
 			dprintk("Already at target state (P%d)\n",
 				next_perf_state);
-			return 0;
+			result = 0;
+			goto out;
 		}
 	}
 
 	switch (data->cpu_feature) {
 	case SYSTEM_INTEL_MSR_CAPABLE:
-		cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
-		cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
-		cmd.val = (u32) perf->states[next_perf_state].control;
+		cmd->type = SYSTEM_INTEL_MSR_CAPABLE;
+		cmd->addr.msr.reg = MSR_IA32_PERF_CTL;
+		cmd->val = (u32) perf->states[next_perf_state].control;
 		break;
 	case SYSTEM_IO_CAPABLE:
-		cmd.type = SYSTEM_IO_CAPABLE;
-		cmd.addr.io.port = perf->control_register.address;
-		cmd.addr.io.bit_width = perf->control_register.bit_width;
-		cmd.val = (u32) perf->states[next_perf_state].control;
+		cmd->type = SYSTEM_IO_CAPABLE;
+		cmd->addr.io.port = perf->control_register.address;
+		cmd->addr.io.bit_width = perf->control_register.bit_width;
+		cmd->val = (u32) perf->states[next_perf_state].control;
 		break;
 	default:
-		return -ENODEV;
+		result = -ENODEV;
+		goto out;
 	}
 
-	cpus_clear(cmd.mask);
+	cpus_clear(cmd->mask);
 
 	if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
-		cmd.mask = online_policy_cpus;
+		cmd->mask = *online_policy_cpus;
 	else
-		cpu_set(policy->cpu, cmd.mask);
+		cpu_set(policy->cpu, cmd->mask);
 
 	freqs.old = perf->states[perf->state].core_frequency * 1000;
 	freqs.new = data->freq_table[next_state].frequency;
-	for_each_cpu_mask_nr(i, cmd.mask) {
+	for_each_cpu_mask_nr(i, cmd->mask) {
 		freqs.cpu = i;
 		cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
 	}
 
-	drv_write(&cmd);
+	drv_write(cmd);
 
 	if (acpi_pstate_strict) {
-		if (!check_freqs(&cmd.mask, freqs.new, data)) {
+		if (!check_freqs(&cmd->mask, freqs.new, data)) {
 			dprintk("acpi_cpufreq_target failed (%d)\n",
 				policy->cpu);
-			return -EAGAIN;
+			result = -EAGAIN;
+			goto out;
 		}
 	}
 
-	for_each_cpu_mask_nr(i, cmd.mask) {
+	for_each_cpu_mask_nr(i, cmd->mask) {
 		freqs.cpu = i;
 		cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
 	}
 	perf->state = next_perf_state;
 
+out:
+	put_cpumask_var(online_policy_cpus, temp_cpumask);
+	put_cpu_var(temp_cmd);
+
 	return result;
 }
 

-- 

[RFC 09/13] genapic: reduce stack pressuge in io_apic.c step 1 temp cpumask_ts

[Mike Travis]

[-- Attachment #1: stack-hogs-io_apic_c-step-1-temp-cpumask_ts --]
[-- Type: text/plain, Size: 19048 bytes --]

  * Step 1 of cleaning up io_apic.c removes local cpumask_t variables
    from the stack.

  - Method 1: remove unnecessary "extra" cpumask variables.

  - Method 2: use for_each_online_cpu_mask_nr() to logically AND
              the passed in mask with cpu_online_map, eliminating
	      the need for a temp cpumask variable.

  - Method 3: use get_cpumask_var variables where possible. The current
    assignment of temp variables is:
	

    /*
     * Temporary cpumask variables
     *
     * (XXX - would be _MUCH_ better as a "stack" of temp cpumasks.)
     *
     * level 4:
     *     irq_complete_move()
     *     check_timer()
     *     msi_compose_msg()
     *     set_msi_irq_affinity()
     *     ir_set_msi_irq_affinity()
     *     dmar_msi_set_affinity()
     *     set_ht_irq_affinity()
     *     arch_setup_ht_irq()
     *     setup_ioapic_dest()
     *
     * level 3:
     *     set_ioapic_affinity_irq()
     *     setup_IO_APIC_irq()
     *     migrate_ioapic_irq()
     *
     * level 2:
     *     create_irq_nr()
     *
     * level 1:
     *     __assign_irq_vector()
     *     setup_timer_IRQ0_pin()
     */

  * Addition of temp cpumask variables for the "target" of TARGET_CPUS
    is in preparation of changing the TARGET_CPUS for x86_64.  I've
    kept those changes here to document which routines get which temp
    cpumask variables.

  * Total stack size savings are in the last step.

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/io_apic.c |  268 ++++++++++++++++++++++++++++++----------------
 1 file changed, 175 insertions(+), 93 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/io_apic.c
+++ linux-2.6.tip/arch/x86/kernel/io_apic.c
@@ -41,6 +41,7 @@
 #endif
 #include <linux/bootmem.h>
 #include <linux/dmar.h>
+#include <linux/cpumask_ptr.h>
 
 #include <asm/idle.h>
 #include <asm/io.h>
@@ -93,6 +94,39 @@ int mp_bus_id_to_type[MAX_MP_BUSSES];
 
 DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
 
+/*
+ * Temporary cpumask variables
+ *
+ * (XXX - would be _MUCH_ better as a "stack" of temp cpumasks.)
+ *
+ * level 4:
+ *     irq_complete_move()
+ *     check_timer()
+ *     msi_compose_msg()
+ *     set_msi_irq_affinity()
+ *     ir_set_msi_irq_affinity()
+ *     dmar_msi_set_affinity()
+ *     set_ht_irq_affinity()
+ *     arch_setup_ht_irq()
+ *     setup_ioapic_dest()
+ *
+ * level 3:
+ *     set_ioapic_affinity_irq()
+ *     setup_IO_APIC_irq()
+ *     migrate_ioapic_irq()
+ *
+ * level 2:
+ *     create_irq_nr()
+ *
+ * level 1:
+ *     __assign_irq_vector()
+ *     setup_timer_IRQ0_pin()
+ */
+static DEFINE_PER_CPUMASK(cpumask_irq_level_4);
+static DEFINE_PER_CPUMASK(cpumask_irq_level_3);
+static DEFINE_PER_CPUMASK(cpumask_irq_level_2);
+static DEFINE_PER_CPUMASK(cpumask_irq_level_1);
+
 int skip_ioapic_setup;
 
 static int __init parse_noapic(char *str)
@@ -551,19 +585,24 @@ static void set_ioapic_affinity_irq(unsi
 	struct irq_cfg *cfg;
 	unsigned long flags;
 	unsigned int dest;
-	cpumask_t tmp;
+	cpumask_ptr tmp;
 	struct irq_desc *desc;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
+	get_cpumask_var(tmp, cpumask_irq_level_3);
+	cpus_and(*tmp, mask, cpu_online_map);
+	if (cpus_empty(*tmp)) {
+		put_cpumask_var(tmp, cpumask_irq_level_3);
 		return;
+	}
 
 	cfg = irq_cfg(irq);
-	if (assign_irq_vector(irq, mask))
+	if (assign_irq_vector(irq, mask)) {
+		put_cpumask_var(tmp, cpumask_irq_level_3);
 		return;
+	}
 
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmp, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmp);
 	/*
 	 * Only the high 8 bits are valid.
 	 */
@@ -574,6 +613,7 @@ static void set_ioapic_affinity_irq(unsi
 	__target_IO_APIC_irq(irq, dest, cfg->vector);
 	desc->affinity = mask;
 	spin_unlock_irqrestore(&ioapic_lock, flags);
+	put_cpumask_var(tmp, cpumask_irq_level_3);
 }
 #endif /* CONFIG_SMP */
 
@@ -1206,7 +1246,7 @@ void unlock_vector_lock(void)
 	spin_unlock(&vector_lock);
 }
 
-static int __assign_irq_vector(int irq, cpumask_t mask)
+static int __assign_irq_vector(int irq, cpumask_t inmask)
 {
 	/*
 	 * NOTE! The local APIC isn't very good at handling
@@ -1223,37 +1263,37 @@ static int __assign_irq_vector(int irq, 
 	unsigned int old_vector;
 	int cpu;
 	struct irq_cfg *cfg;
+	cpumask_ptr tmpmask;
 
 	cfg = irq_cfg(irq);
-
-	/* Only try and allocate irqs on cpus that are present */
-	cpus_and(mask, mask, cpu_online_map);
-
 	if ((cfg->move_in_progress) || cfg->move_cleanup_count)
 		return -EBUSY;
 
+	/* Only try and allocate irqs on cpus that are present */
+	get_cpumask_var(tmpmask, cpumask_irq_level_1);
+
 	old_vector = cfg->vector;
 	if (old_vector) {
-		cpumask_t tmp;
-		cpus_and(tmp, cfg->domain, mask);
-		if (!cpus_empty(tmp))
+		cpus_and(*tmpmask, inmask, cpu_online_map);
+		cpus_and(*tmpmask, cfg->domain, *tmpmask);
+		if (!cpus_empty(*tmpmask)) {
+			put_cpumask_var(tmpmask, cpumask_irq_level_1);
 			return 0;
+		}
 	}
 
-	for_each_cpu_mask_nr(cpu, mask) {
-		cpumask_t domain, new_mask;
+	for_each_online_cpu_mask_nr(cpu, inmask) {
 		int new_cpu;
 		int vector, offset;
 
-		domain = vector_allocation_domain(cpu);
-		cpus_and(new_mask, domain, cpu_online_map);
+		*tmpmask = vector_allocation_domain(cpu);
 
 		vector = current_vector;
 		offset = current_offset;
 next:
 		vector += 8;
 		if (vector >= first_system_vector) {
-			/* If we run out of vectors on large boxen, must share them. */
+			/* If no more vectors on large boxen, must share them */
 			offset = (offset + 1) % 8;
 			vector = FIRST_DEVICE_VECTOR + offset;
 		}
@@ -1266,7 +1306,7 @@ next:
 		if (vector == SYSCALL_VECTOR)
 			goto next;
 #endif
-		for_each_cpu_mask_nr(new_cpu, new_mask)
+		for_each_online_cpu_mask_nr(new_cpu, *tmpmask)
 			if (per_cpu(vector_irq, new_cpu)[vector] != -1)
 				goto next;
 		/* Found one! */
@@ -1276,12 +1316,14 @@ next:
 			cfg->move_in_progress = 1;
 			cfg->old_domain = cfg->domain;
 		}
-		for_each_cpu_mask_nr(new_cpu, new_mask)
+		for_each_online_cpu_mask_nr(new_cpu, *tmpmask)
 			per_cpu(vector_irq, new_cpu)[vector] = irq;
 		cfg->vector = vector;
-		cfg->domain = domain;
+		cfg->domain = *tmpmask;
+		put_cpumask_var(tmpmask, cpumask_irq_level_1);
 		return 0;
 	}
+	put_cpumask_var(tmpmask, cpumask_irq_level_1);
 	return -ENOSPC;
 }
 
@@ -1299,15 +1341,13 @@ static int assign_irq_vector(int irq, cp
 static void __clear_irq_vector(int irq)
 {
 	struct irq_cfg *cfg;
-	cpumask_t mask;
 	int cpu, vector;
 
 	cfg = irq_cfg(irq);
 	BUG_ON(!cfg->vector);
 
 	vector = cfg->vector;
-	cpus_and(mask, cfg->domain, cpu_online_map);
-	for_each_cpu_mask_nr(cpu, mask)
+	for_each_online_cpu_mask_nr(cpu, cfg->domain)
 		per_cpu(vector_irq, cpu)[vector] = -1;
 
 	cfg->vector = 0;
@@ -1478,18 +1518,19 @@ static void setup_IO_APIC_irq(int apic, 
 {
 	struct irq_cfg *cfg;
 	struct IO_APIC_route_entry entry;
-	cpumask_t mask;
+	cpumask_ptr mask;
 
 	if (!IO_APIC_IRQ(irq))
 		return;
 
 	cfg = irq_cfg(irq);
 
-	mask = TARGET_CPUS;
-	if (assign_irq_vector(irq, mask))
-		return;
+	get_cpumask_var(mask, cpumask_irq_level_3);
+	*mask = TARGET_CPUS;
+	if (assign_irq_vector(irq, *mask))
+		goto out;
 
-	cpus_and(mask, cfg->domain, mask);
+	cpus_and(*mask, cfg->domain, *mask);
 
 	apic_printk(APIC_VERBOSE,KERN_DEBUG
 		    "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
@@ -1499,12 +1540,12 @@ static void setup_IO_APIC_irq(int apic, 
 
 
 	if (setup_ioapic_entry(mp_ioapics[apic].mp_apicid, irq, &entry,
-			       cpu_mask_to_apicid(mask), trigger, polarity,
+			       cpu_mask_to_apicid(*mask), trigger, polarity,
 			       cfg->vector)) {
 		printk("Failed to setup ioapic entry for ioapic  %d, pin %d\n",
 		       mp_ioapics[apic].mp_apicid, pin);
 		__clear_irq_vector(irq);
-		return;
+		goto out;
 	}
 
 	ioapic_register_intr(irq, trigger);
@@ -1512,6 +1553,8 @@ static void setup_IO_APIC_irq(int apic, 
 		disable_8259A_irq(irq);
 
 	ioapic_write_entry(apic, pin, entry);
+out:
+	put_cpumask_var(mask, cpumask_irq_level_3);
 }
 
 static void __init setup_IO_APIC_irqs(void)
@@ -1560,6 +1603,7 @@ static void __init setup_timer_IRQ0_pin(
 					int vector)
 {
 	struct IO_APIC_route_entry entry;
+	cpumask_ptr tgt_cpus;
 
 #ifdef CONFIG_INTR_REMAP
 	if (intr_remapping_enabled)
@@ -1567,6 +1611,8 @@ static void __init setup_timer_IRQ0_pin(
 #endif
 
 	memset(&entry, 0, sizeof(entry));
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_1);
+	*tgt_cpus = TARGET_CPUS;
 
 	/*
 	 * We use logical delivery to get the timer IRQ
@@ -1574,7 +1620,7 @@ static void __init setup_timer_IRQ0_pin(
 	 */
 	entry.dest_mode = INT_DEST_MODE;
 	entry.mask = 1;					/* mask IRQ now */
-	entry.dest = cpu_mask_to_apicid(TARGET_CPUS);
+	entry.dest = cpu_mask_to_apicid(*tgt_cpus);
 	entry.delivery_mode = INT_DELIVERY_MODE;
 	entry.polarity = 0;
 	entry.trigger = 0;
@@ -1590,6 +1636,7 @@ static void __init setup_timer_IRQ0_pin(
 	 * Add it to the IO-APIC irq-routing table:
 	 */
 	ioapic_write_entry(apic, pin, entry);
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_1);
 }
 
 
@@ -2250,25 +2297,26 @@ static void migrate_ioapic_irq(int irq, 
 {
 	struct irq_cfg *cfg;
 	struct irq_desc *desc;
-	cpumask_t tmp, cleanup_mask;
+	cpumask_ptr tmpmask;
 	struct irte irte;
 	int modify_ioapic_rte;
 	unsigned int dest;
 	unsigned long flags;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
-		return;
+	get_cpumask_var(tmpmask, cpumask_irq_level_3);
+	cpus_and(*tmpmask, mask, cpu_online_map);
+	if (cpus_empty(*tmpmask))
+		goto out;
 
 	if (get_irte(irq, &irte))
-		return;
+		goto out;
 
 	if (assign_irq_vector(irq, mask))
-		return;
+		goto out;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmpmask, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmpmask);
 
 	desc = irq_to_desc(irq);
 	modify_ioapic_rte = desc->status & IRQ_LEVEL;
@@ -2287,13 +2335,15 @@ static void migrate_ioapic_irq(int irq, 
 	modify_irte(irq, &irte);
 
 	if (cfg->move_in_progress) {
-		cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map);
-		cfg->move_cleanup_count = cpus_weight(cleanup_mask);
-		send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
+		cpus_and(*tmpmask, cfg->old_domain, cpu_online_map);
+		cfg->move_cleanup_count = cpus_weight(*tmpmask);
+		send_IPI_mask(*tmpmask, IRQ_MOVE_CLEANUP_VECTOR);
 		cfg->move_in_progress = 0;
 	}
 
 	desc->affinity = mask;
+out:
+	put_cpumask_var(tmpmask, cpumask_irq_level_3);
 }
 
 static int migrate_irq_remapped_level(int irq)
@@ -2415,11 +2465,13 @@ static void irq_complete_move(unsigned i
 	vector = ~get_irq_regs()->orig_ax;
 	me = smp_processor_id();
 	if ((vector == cfg->vector) && cpu_isset(me, cfg->domain)) {
-		cpumask_t cleanup_mask;
+		cpumask_ptr cleanup_mask;
 
-		cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map);
-		cfg->move_cleanup_count = cpus_weight(cleanup_mask);
-		send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
+		get_cpumask_var(cleanup_mask, cpumask_irq_level_4);
+		cpus_and(*cleanup_mask, cfg->old_domain, cpu_online_map);
+		cfg->move_cleanup_count = cpus_weight(*cleanup_mask);
+		send_IPI_mask(*cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
+		put_cpumask_var(cleanup_mask, cpumask_irq_level_4);
 		cfg->move_in_progress = 0;
 	}
 }
@@ -2749,6 +2801,7 @@ static inline void __init check_timer(vo
 	unsigned long flags;
 	unsigned int ver;
 	int no_pin1 = 0;
+	cpumask_ptr tgt_cpus;
 
 	local_irq_save(flags);
 
@@ -2759,7 +2812,10 @@ static inline void __init check_timer(vo
 	 * get/set the timer IRQ vector:
 	 */
 	disable_8259A_irq(0);
-	assign_irq_vector(0, TARGET_CPUS);
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
+	*tgt_cpus = TARGET_CPUS;
+	assign_irq_vector(0, *tgt_cpus);
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 
 	/*
 	 * As IRQ0 is to be enabled in the 8259A, the virtual
@@ -3059,12 +3115,15 @@ unsigned int create_irq_nr(unsigned int 
 	unsigned int new;
 	unsigned long flags;
 	struct irq_cfg *cfg_new;
+	cpumask_ptr tgt_cpus;
 
 #ifndef CONFIG_HAVE_SPARSE_IRQ
 	irq_want = nr_irqs - 1;
 #endif
 
 	irq = 0;
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_2);
+	*tgt_cpus = TARGET_CPUS;
 	spin_lock_irqsave(&vector_lock, flags);
 	for (new = irq_want; new > 0; new--) {
 		if (platform_legacy_irq(new))
@@ -3075,11 +3134,12 @@ unsigned int create_irq_nr(unsigned int 
 		/* check if need to create one */
 		if (!cfg_new)
 			cfg_new = irq_cfg_alloc(new);
-		if (__assign_irq_vector(new, TARGET_CPUS) == 0)
+		if (__assign_irq_vector(new, *tgt_cpus) == 0)
 			irq = new;
 		break;
 	}
 	spin_unlock_irqrestore(&vector_lock, flags);
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_2);
 
 	if (irq > 0) {
 		dynamic_irq_init(irq);
@@ -3122,16 +3182,18 @@ static int msi_compose_msg(struct pci_de
 	struct irq_cfg *cfg;
 	int err;
 	unsigned dest;
-	cpumask_t tmp;
+	cpumask_ptr tgt_cpus;
 
-	tmp = TARGET_CPUS;
-	err = assign_irq_vector(irq, tmp);
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
+	*tgt_cpus = TARGET_CPUS;
+	err = assign_irq_vector(irq, *tgt_cpus);
 	if (err)
 		return err;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, tmp);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tgt_cpus, cfg->domain, *tgt_cpus);
+	dest = cpu_mask_to_apicid(*tgt_cpus);
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 
 #ifdef CONFIG_INTR_REMAP
 	if (irq_remapped(irq)) {
@@ -3190,19 +3252,20 @@ static void set_msi_irq_affinity(unsigne
 	struct irq_cfg *cfg;
 	struct msi_msg msg;
 	unsigned int dest;
-	cpumask_t tmp;
+	cpumask_ptr tmp;
 	struct irq_desc *desc;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
-		return;
+	get_cpumask_var(tmp, cpumask_irq_level_4);
+	cpus_and(*tmp, mask, cpu_online_map);
+	if (cpus_empty(*tmp))
+		goto out;
 
 	if (assign_irq_vector(irq, mask))
-		return;
+		goto out;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmp, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmp);
 
 	read_msi_msg(irq, &msg);
 
@@ -3214,6 +3277,8 @@ static void set_msi_irq_affinity(unsigne
 	write_msi_msg(irq, &msg);
 	desc = irq_to_desc(irq);
 	desc->affinity = mask;
+out:
+	put_cpumask_var(tmp, cpumask_irq_level_4);
 }
 
 #ifdef CONFIG_INTR_REMAP
@@ -3225,12 +3290,13 @@ static void ir_set_msi_irq_affinity(unsi
 {
 	struct irq_cfg *cfg;
 	unsigned int dest;
-	cpumask_t tmp, cleanup_mask;
+	cpumask_ptr tmp;
 	struct irte irte;
 	struct irq_desc *desc;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
+	get_cpumask_var(tmp, cpumask_irq_level_4);
+	cpus_and(*tmp, mask, cpu_online_map);
+	if (cpus_empty(*tmp))
 		return;
 
 	if (get_irte(irq, &irte))
@@ -3240,8 +3306,8 @@ static void ir_set_msi_irq_affinity(unsi
 		return;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmp, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmp);
 
 	irte.vector = cfg->vector;
 	irte.dest_id = IRTE_DEST(dest);
@@ -3257,14 +3323,15 @@ static void ir_set_msi_irq_affinity(unsi
 	 * vector allocation.
 	 */
 	if (cfg->move_in_progress) {
-		cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map);
-		cfg->move_cleanup_count = cpus_weight(cleanup_mask);
-		send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
+		cpus_and(*tmp, cfg->old_domain, cpu_online_map);
+		cfg->move_cleanup_count = cpus_weight(*tmp);
+		send_IPI_mask(*tmp, IRQ_MOVE_CLEANUP_VECTOR);
 		cfg->move_in_progress = 0;
 	}
 
 	desc = irq_to_desc(irq);
 	desc->affinity = mask;
+	put_cpumask_var(tmp, cpumask_irq_level_4);
 }
 #endif
 #endif /* CONFIG_SMP */
@@ -3469,19 +3536,20 @@ static void dmar_msi_set_affinity(unsign
 	struct irq_cfg *cfg;
 	struct msi_msg msg;
 	unsigned int dest;
-	cpumask_t tmp;
+	cpumask_ptr tmp;
 	struct irq_desc *desc;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
-		return;
+	get_cpumask_var(tmp, cpumask_irq_level_4);
+	cpus_and(*tmp, mask, cpu_online_map);
+	if (cpus_empty(*tmp))
+		goto out;
 
 	if (assign_irq_vector(irq, mask))
-		return;
+		goto out;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmp, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmp);
 
 	dmar_msi_read(irq, &msg);
 
@@ -3493,6 +3561,8 @@ static void dmar_msi_set_affinity(unsign
 	dmar_msi_write(irq, &msg);
 	desc = irq_to_desc(irq);
 	desc->affinity = mask;
+out:
+	put_cpumask_var(tmp, cpumask_irq_level_4);
 }
 #endif /* CONFIG_SMP */
 
@@ -3548,23 +3618,26 @@ static void set_ht_irq_affinity(unsigned
 {
 	struct irq_cfg *cfg;
 	unsigned int dest;
-	cpumask_t tmp;
+	cpumask_ptr tmp;
 	struct irq_desc *desc;
 
-	cpus_and(tmp, mask, cpu_online_map);
-	if (cpus_empty(tmp))
-		return;
+	get_cpumask_var(tmp, cpumask_irq_level_4);
+	cpus_and(*tmp, mask, cpu_online_map);
+	if (cpus_empty(*tmp))
+		goto out;
 
 	if (assign_irq_vector(irq, mask))
-		return;
+		goto out;
 
 	cfg = irq_cfg(irq);
-	cpus_and(tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(tmp);
+	cpus_and(*tmp, cfg->domain, mask);
+	dest = cpu_mask_to_apicid(*tmp);
 
 	target_ht_irq(irq, dest, cfg->vector);
 	desc = irq_to_desc(irq);
 	desc->affinity = mask;
+out:
+	put_cpumask_var(tmp, cpumask_irq_level_4);
 }
 #endif
 
@@ -3583,17 +3656,18 @@ int arch_setup_ht_irq(unsigned int irq, 
 {
 	struct irq_cfg *cfg;
 	int err;
-	cpumask_t tmp;
+	cpumask_ptr tgt_cpus;
 
-	tmp = TARGET_CPUS;
-	err = assign_irq_vector(irq, tmp);
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
+	*tgt_cpus = TARGET_CPUS;
+	err = assign_irq_vector(irq, *tgt_cpus);
 	if (!err) {
 		struct ht_irq_msg msg;
 		unsigned dest;
 
 		cfg = irq_cfg(irq);
-		cpus_and(tmp, cfg->domain, tmp);
-		dest = cpu_mask_to_apicid(tmp);
+		cpus_and(*tgt_cpus, cfg->domain, *tgt_cpus);
+		dest = cpu_mask_to_apicid(*tgt_cpus);
 
 		msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
 
@@ -3615,6 +3689,7 @@ int arch_setup_ht_irq(unsigned int irq, 
 		set_irq_chip_and_handler_name(irq, &ht_irq_chip,
 					      handle_edge_irq, "edge");
 	}
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 	return err;
 }
 #endif /* CONFIG_HT_IRQ */
@@ -3799,10 +3874,12 @@ void __init setup_ioapic_dest(void)
 {
 	int pin, ioapic, irq, irq_entry;
 	struct irq_cfg *cfg;
+	cpumask_ptr tgt_cpus;
 
 	if (skip_ioapic_setup == 1)
 		return;
 
+	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 	for (ioapic = 0; ioapic < nr_ioapics; ioapic++) {
 		for (pin = 0; pin < nr_ioapic_registers[ioapic]; pin++) {
 			irq_entry = find_irq_entry(ioapic, pin, mp_INT);
@@ -3820,14 +3897,19 @@ void __init setup_ioapic_dest(void)
 						  irq_trigger(irq_entry),
 						  irq_polarity(irq_entry));
 #ifdef CONFIG_INTR_REMAP
-			else if (intr_remapping_enabled)
-				set_ir_ioapic_affinity_irq(irq, TARGET_CPUS);
+			else if (intr_remapping_enabled) {
+				*tgt_cpus = TARGET_CPUS;
+				set_ir_ioapic_affinity_irq(irq, *tgt_cpus);
+			}
 #endif
-			else
-				set_ioapic_affinity_irq(irq, TARGET_CPUS);
+			else {
+				*tgt_cpus = TARGET_CPUS;
+				set_ioapic_affinity_irq(irq, *tgt_cpus);
+			}
 		}
 
 	}
+	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 }
 #endif
 

-- 

Re: [RFC 09/13] genapic: reduce stack pressuge in io_apic.c step 1 temp cpumask_ts

[Andi Kleen]

Mike Travis <travis@sgi.com> writes:

>   * Step 1 of cleaning up io_apic.c removes local cpumask_t variables
>     from the stack.

Sorry that patch seems incredibly messy. Global variables
and a tricky ordering and while it's at least commented it's still a mess
and maintenance unfriendly.

Also I think set_affinity is the only case where a truly arbitary cpu
mask can be passed in anyways. And it's passed in from elsewhere. 

The other cases generally just want to handle a subset of CPUs which
are nearby. How about you define a new cpumask like type that 
consists of a start/stop CPU and a mask for that range only 
and is not larger than a few words?

I think with that the nearby assignments could be handled 
reasonably cleanly with arguments and local variables.

And I suspect with some restructuring set_affinity could
be also made to support such a model.

-Andi

Re: [RFC 09/13] genapic: reduce stack pressuge in io_apic.c step 1 temp cpumask_ts

[Mike Travis]

Andi Kleen wrote:
> Mike Travis <travis@sgi.com> writes:
> 
>>   * Step 1 of cleaning up io_apic.c removes local cpumask_t variables
>>     from the stack.
> 
> Sorry that patch seems incredibly messy. Global variables
> and a tricky ordering and while it's at least commented it's still a mess
> and maintenance unfriendly.
> 
> Also I think set_affinity is the only case where a truly arbitary cpu
> mask can be passed in anyways. And it's passed in from elsewhere. 
> 
> The other cases generally just want to handle a subset of CPUs which
> are nearby. How about you define a new cpumask like type that 
> consists of a start/stop CPU and a mask for that range only 
> and is not larger than a few words?
> 
> I think with that the nearby assignments could be handled 
> reasonably cleanly with arguments and local variables.
> 
> And I suspect with some restructuring set_affinity could
> be also made to support such a model.
> 
> -Andi

Thanks for the comments.  I did mull over something like this early on
in researching this "cpumask" problem, but the problem of having different
cpumask operators didn't seem worthwhile.  But perhaps for a very limited
use (with very few ops), it would be worthwhile.

But how big to make these?  Variable sized?  Config option?  Should I
introduce some kind of MAX_CPUS_PER_NODE constant?  (NR_CPUS/MAX_NUMNODES
I don't think is the right answer.)

Thanks,
Mike

[RFC 10/13] genapic: reduce stack pressuge in io_apic.c step 2 internal abi

[Mike Travis]

[-- Attachment #1: stack-hogs-io_apic_c-step-2-internal-abi --]
[-- Type: text/plain, Size: 7922 bytes --]

  * Step 2 of cleaning up io_apic.c removes cpumask_t variables
    passed as arguments on the stack for internal functions:

	assign_irq_vector()
	__assign_irq_vector()
	migrate_ioapic_irq()
	set_ioapic_affinity_irq()
	set_ir_ioapic_affinity_irq()

   The last two functions are used both internally and externally so
   there are now intermediate functions to maintain the external ABI.

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/io_apic.c |   66 +++++++++++++++++++++++++++-------------------
 1 file changed, 39 insertions(+), 27 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/io_apic.c
+++ linux-2.6.tip/arch/x86/kernel/io_apic.c
@@ -578,9 +578,9 @@ static void __target_IO_APIC_irq(unsigne
 	}
 }
 
-static int assign_irq_vector(int irq, cpumask_t mask);
+static int assign_irq_vector(int irq, cpumask_t *mask);
 
-static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t mask)
+static void set_ioapic_affinity_irq_p(unsigned int irq, cpumask_t *mask)
 {
 	struct irq_cfg *cfg;
 	unsigned long flags;
@@ -589,7 +589,7 @@ static void set_ioapic_affinity_irq(unsi
 	struct irq_desc *desc;
 
 	get_cpumask_var(tmp, cpumask_irq_level_3);
-	cpus_and(*tmp, mask, cpu_online_map);
+	cpus_and(*tmp, *mask, cpu_online_map);
 	if (cpus_empty(*tmp)) {
 		put_cpumask_var(tmp, cpumask_irq_level_3);
 		return;
@@ -601,7 +601,7 @@ static void set_ioapic_affinity_irq(unsi
 		return;
 	}
 
-	cpus_and(*tmp, cfg->domain, mask);
+	cpus_and(*tmp, cfg->domain, *mask);
 	dest = cpu_mask_to_apicid(*tmp);
 	/*
 	 * Only the high 8 bits are valid.
@@ -611,10 +611,16 @@ static void set_ioapic_affinity_irq(unsi
 	desc = irq_to_desc(irq);
 	spin_lock_irqsave(&ioapic_lock, flags);
 	__target_IO_APIC_irq(irq, dest, cfg->vector);
-	desc->affinity = mask;
+	desc->affinity = *mask;
 	spin_unlock_irqrestore(&ioapic_lock, flags);
 	put_cpumask_var(tmp, cpumask_irq_level_3);
 }
+
+/* for struct irq_chip.set_affinity compatibility */
+static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t mask)
+{
+	set_ioapic_affinity_irq_p(irq, &mask);
+}
 #endif /* CONFIG_SMP */
 
 /*
@@ -1246,7 +1252,7 @@ void unlock_vector_lock(void)
 	spin_unlock(&vector_lock);
 }
 
-static int __assign_irq_vector(int irq, cpumask_t inmask)
+static int __assign_irq_vector(int irq, cpumask_t *inmask)
 {
 	/*
 	 * NOTE! The local APIC isn't very good at handling
@@ -1274,7 +1280,7 @@ static int __assign_irq_vector(int irq, 
 
 	old_vector = cfg->vector;
 	if (old_vector) {
-		cpus_and(*tmpmask, inmask, cpu_online_map);
+		cpus_and(*tmpmask, *inmask, cpu_online_map);
 		cpus_and(*tmpmask, cfg->domain, *tmpmask);
 		if (!cpus_empty(*tmpmask)) {
 			put_cpumask_var(tmpmask, cpumask_irq_level_1);
@@ -1282,7 +1288,7 @@ static int __assign_irq_vector(int irq, 
 		}
 	}
 
-	for_each_online_cpu_mask_nr(cpu, inmask) {
+	for_each_online_cpu_mask_nr(cpu, *inmask) {
 		int new_cpu;
 		int vector, offset;
 
@@ -1327,7 +1333,7 @@ next:
 	return -ENOSPC;
 }
 
-static int assign_irq_vector(int irq, cpumask_t mask)
+static int assign_irq_vector(int irq, cpumask_t *mask)
 {
 	int err;
 	unsigned long flags;
@@ -1527,7 +1533,7 @@ static void setup_IO_APIC_irq(int apic, 
 
 	get_cpumask_var(mask, cpumask_irq_level_3);
 	*mask = TARGET_CPUS;
-	if (assign_irq_vector(irq, *mask))
+	if (assign_irq_vector(irq, mask))
 		goto out;
 
 	cpus_and(*mask, cfg->domain, *mask);
@@ -2293,7 +2299,7 @@ static DECLARE_DELAYED_WORK(ir_migration
  * as simple as edge triggered migration and we can do the irq migration
  * with a simple atomic update to IO-APIC RTE.
  */
-static void migrate_ioapic_irq(int irq, cpumask_t mask)
+static void migrate_ioapic_irq(int irq, cpumask_t *mask)
 {
 	struct irq_cfg *cfg;
 	struct irq_desc *desc;
@@ -2304,7 +2310,7 @@ static void migrate_ioapic_irq(int irq, 
 	unsigned long flags;
 
 	get_cpumask_var(tmpmask, cpumask_irq_level_3);
-	cpus_and(*tmpmask, mask, cpu_online_map);
+	cpus_and(*tmpmask, *mask, cpu_online_map);
 	if (cpus_empty(*tmpmask))
 		goto out;
 
@@ -2315,7 +2321,7 @@ static void migrate_ioapic_irq(int irq, 
 		goto out;
 
 	cfg = irq_cfg(irq);
-	cpus_and(*tmpmask, cfg->domain, mask);
+	cpus_and(*tmpmask, cfg->domain, *mask);
 	dest = cpu_mask_to_apicid(*tmpmask);
 
 	desc = irq_to_desc(irq);
@@ -2341,7 +2347,7 @@ static void migrate_ioapic_irq(int irq, 
 		cfg->move_in_progress = 0;
 	}
 
-	desc->affinity = mask;
+	desc->affinity = *mask;
 out:
 	put_cpumask_var(tmpmask, cpumask_irq_level_3);
 }
@@ -2365,7 +2371,7 @@ static int migrate_irq_remapped_level(in
 	}
 
 	/* everthing is clear. we have right of way */
-	migrate_ioapic_irq(irq, desc->pending_mask);
+	migrate_ioapic_irq(irq, &desc->pending_mask);
 
 	ret = 0;
 	desc->status &= ~IRQ_MOVE_PENDING;
@@ -2402,19 +2408,25 @@ static void ir_irq_migration(struct work
 /*
  * Migrates the IRQ destination in the process context.
  */
-static void set_ir_ioapic_affinity_irq(unsigned int irq, cpumask_t mask)
+static void set_ir_ioapic_affinity_irq_p(unsigned int irq, cpumask_t *mask)
 {
 	struct irq_desc *desc = irq_to_desc(irq);
 
 	if (desc->status & IRQ_LEVEL) {
 		desc->status |= IRQ_MOVE_PENDING;
-		desc->pending_mask = mask;
+		desc->pending_mask = *mask;
 		migrate_irq_remapped_level(irq);
 		return;
 	}
 
 	migrate_ioapic_irq(irq, mask);
 }
+
+/* for struct irq_chip.set_affinity compatibility */
+static void set_ir_ioapic_affinity_irq(unsigned int irq, cpumask_t mask)
+{
+	set_ir_ioapic_affinity_irq_p(irq, &mask)
+}
 #endif
 
 asmlinkage void smp_irq_move_cleanup_interrupt(void)
@@ -2814,7 +2826,7 @@ static inline void __init check_timer(vo
 	disable_8259A_irq(0);
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 	*tgt_cpus = TARGET_CPUS;
-	assign_irq_vector(0, *tgt_cpus);
+	assign_irq_vector(0, tgt_cpus);
 	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 
 	/*
@@ -3134,7 +3146,7 @@ unsigned int create_irq_nr(unsigned int 
 		/* check if need to create one */
 		if (!cfg_new)
 			cfg_new = irq_cfg_alloc(new);
-		if (__assign_irq_vector(new, *tgt_cpus) == 0)
+		if (__assign_irq_vector(new, tgt_cpus) == 0)
 			irq = new;
 		break;
 	}
@@ -3186,7 +3198,7 @@ static int msi_compose_msg(struct pci_de
 
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 	*tgt_cpus = TARGET_CPUS;
-	err = assign_irq_vector(irq, *tgt_cpus);
+	err = assign_irq_vector(irq, tgt_cpus);
 	if (err)
 		return err;
 
@@ -3260,7 +3272,7 @@ static void set_msi_irq_affinity(unsigne
 	if (cpus_empty(*tmp))
 		goto out;
 
-	if (assign_irq_vector(irq, mask))
+	if (assign_irq_vector(irq, &mask))
 		goto out;
 
 	cfg = irq_cfg(irq);
@@ -3302,7 +3314,7 @@ static void ir_set_msi_irq_affinity(unsi
 	if (get_irte(irq, &irte))
 		return;
 
-	if (assign_irq_vector(irq, mask))
+	if (assign_irq_vector(irq, &mask))
 		return;
 
 	cfg = irq_cfg(irq);
@@ -3544,7 +3556,7 @@ static void dmar_msi_set_affinity(unsign
 	if (cpus_empty(*tmp))
 		goto out;
 
-	if (assign_irq_vector(irq, mask))
+	if (assign_irq_vector(irq, &mask))
 		goto out;
 
 	cfg = irq_cfg(irq);
@@ -3626,7 +3638,7 @@ static void set_ht_irq_affinity(unsigned
 	if (cpus_empty(*tmp))
 		goto out;
 
-	if (assign_irq_vector(irq, mask))
+	if (assign_irq_vector(irq, &mask))
 		goto out;
 
 	cfg = irq_cfg(irq);
@@ -3660,7 +3672,7 @@ int arch_setup_ht_irq(unsigned int irq, 
 
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 	*tgt_cpus = TARGET_CPUS;
-	err = assign_irq_vector(irq, *tgt_cpus);
+	err = assign_irq_vector(irq, tgt_cpus);
 	if (!err) {
 		struct ht_irq_msg msg;
 		unsigned dest;
@@ -3899,12 +3911,12 @@ void __init setup_ioapic_dest(void)
 #ifdef CONFIG_INTR_REMAP
 			else if (intr_remapping_enabled) {
 				*tgt_cpus = TARGET_CPUS;
-				set_ir_ioapic_affinity_irq(irq, *tgt_cpus);
+				set_ir_ioapic_affinity_irq_p(irq, tgt_cpus);
 			}
 #endif
 			else {
 				*tgt_cpus = TARGET_CPUS;
-				set_ioapic_affinity_irq(irq, *tgt_cpus);
+				set_ioapic_affinity_irq_p(irq, tgt_cpus);
 			}
 		}
 

-- 

[RFC 11/13] genapic: reduce stack pressuge in io_apic.c step 3 target_cpus

[Mike Travis]

[-- Attachment #1: stack-hogs-io_apic_c-step-3-target_cpus --]
[-- Type: text/plain, Size: 8323 bytes --]

  * Step 3 "target_cpus" of cleaning up io_apic.c modifies the TARGET_CPUS
    interface to pass a pointer to the returned mask for arch X86_64,
    removing yet another "cpumask_t variable on the stack".

	target_cpus = TARGET_CPUS;

    becomes:

	TARGET_CPUS(target_cpus);

    For x86_32 this is expanded to:

	target_cpus = (genapic->target_cpus());

    For x86_64 this is expanded to:

	target_cpus = (genapic->target_cpus)(&(target_cpus));

  * All the appropriate genapic "target_cpus" functions are modified
    to use this new interface.

  * Note that arch-i386-gcc had trouble with the name of the variables
    being "target_cpus" (conflicted with the macro TARGET_CPUS expanding
    to (target_cpus()), so they are now "tgt_cpus".

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/genapic_flat_64.c        |    8 ++++----
 arch/x86/kernel/genx2apic_cluster.c      |    4 ++--
 arch/x86/kernel/genx2apic_phys.c         |    4 ++--
 arch/x86/kernel/genx2apic_uv_x.c         |    4 ++--
 arch/x86/kernel/io_apic.c                |   16 ++++++++--------
 include/asm-x86/genapic_64.h             |    2 +-
 include/asm-x86/mach-default/mach_apic.h |   28 +++++++++++++++++-----------
 include/asm-x86/mach-generic/mach_apic.h |    6 +++++-
 8 files changed, 41 insertions(+), 31 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/genapic_flat_64.c
+++ linux-2.6.tip/arch/x86/kernel/genapic_flat_64.c
@@ -31,9 +31,9 @@ static int __init flat_acpi_madt_oem_che
 	return 1;
 }
 
-static cpumask_t flat_target_cpus(void)
+static void flat_target_cpus(cpumask_t *retmask)
 {
-	return cpu_online_map;
+	*retmask = cpu_online_map;
 }
 
 static cpumask_t flat_vector_allocation_domain(int cpu)
@@ -194,9 +194,9 @@ static int __init physflat_acpi_madt_oem
 	return 0;
 }
 
-static cpumask_t physflat_target_cpus(void)
+static void physflat_target_cpus(cpumask_t *retmask)
 {
-	return cpu_online_map;
+	*retmask = cpu_online_map;
 }
 
 static cpumask_t physflat_vector_allocation_domain(int cpu)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_cluster.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_cluster.c
@@ -23,9 +23,9 @@ static int __init x2apic_acpi_madt_oem_c
 
 /* Start with all IRQs pointing to boot CPU.  IRQ balancing will shift them. */
 
-static cpumask_t x2apic_target_cpus(void)
+static void x2apic_target_cpus(cpumask_t *retmask)
 {
-	return cpumask_of_cpu(0);
+	*retmask = cpumask_of_cpu(0);
 }
 
 /*
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_phys.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_phys.c
@@ -29,9 +29,9 @@ static int __init x2apic_acpi_madt_oem_c
 
 /* Start with all IRQs pointing to boot CPU.  IRQ balancing will shift them. */
 
-static cpumask_t x2apic_target_cpus(void)
+static void x2apic_target_cpus(cpumask_t *retmask)
 {
-	return cpumask_of_cpu(0);
+	*retmask = cpumask_of_cpu(0);
 }
 
 static cpumask_t x2apic_vector_allocation_domain(int cpu)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_uv_x.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_uv_x.c
@@ -77,9 +77,9 @@ EXPORT_SYMBOL(sn_rtc_cycles_per_second);
 
 /* Start with all IRQs pointing to boot CPU.  IRQ balancing will shift them. */
 
-static cpumask_t uv_target_cpus(void)
+static uv_target_cpus(cpumask_t *retmask)
 {
-	return cpumask_of_cpu(0);
+	*retmask = cpumask_of_cpu(0);
 }
 
 static cpumask_t uv_vector_allocation_domain(int cpu)
--- linux-2.6.tip.orig/arch/x86/kernel/io_apic.c
+++ linux-2.6.tip/arch/x86/kernel/io_apic.c
@@ -1532,7 +1532,7 @@ static void setup_IO_APIC_irq(int apic, 
 	cfg = irq_cfg(irq);
 
 	get_cpumask_var(mask, cpumask_irq_level_3);
-	*mask = TARGET_CPUS;
+	TARGET_CPUS(*mask);
 	if (assign_irq_vector(irq, mask))
 		goto out;
 
@@ -1618,7 +1618,7 @@ static void __init setup_timer_IRQ0_pin(
 
 	memset(&entry, 0, sizeof(entry));
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_1);
-	*tgt_cpus = TARGET_CPUS;
+	TARGET_CPUS(*tgt_cpus);
 
 	/*
 	 * We use logical delivery to get the timer IRQ
@@ -2825,7 +2825,7 @@ static inline void __init check_timer(vo
 	 */
 	disable_8259A_irq(0);
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
-	*tgt_cpus = TARGET_CPUS;
+	TARGET_CPUS(*tgt_cpus);
 	assign_irq_vector(0, tgt_cpus);
 	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 
@@ -3135,7 +3135,7 @@ unsigned int create_irq_nr(unsigned int 
 
 	irq = 0;
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_2);
-	*tgt_cpus = TARGET_CPUS;
+	TARGET_CPUS(*tgt_cpus);
 	spin_lock_irqsave(&vector_lock, flags);
 	for (new = irq_want; new > 0; new--) {
 		if (platform_legacy_irq(new))
@@ -3197,7 +3197,7 @@ static int msi_compose_msg(struct pci_de
 	cpumask_ptr tgt_cpus;
 
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
-	*tgt_cpus = TARGET_CPUS;
+	TARGET_CPUS(*tgt_cpus);
 	err = assign_irq_vector(irq, tgt_cpus);
 	if (err)
 		return err;
@@ -3671,7 +3671,7 @@ int arch_setup_ht_irq(unsigned int irq, 
 	cpumask_ptr tgt_cpus;
 
 	get_cpumask_var(tgt_cpus, cpumask_irq_level_4);
-	*tgt_cpus = TARGET_CPUS;
+	TARGET_CPUS(*tgt_cpus);
 	err = assign_irq_vector(irq, tgt_cpus);
 	if (!err) {
 		struct ht_irq_msg msg;
@@ -3910,12 +3910,12 @@ void __init setup_ioapic_dest(void)
 						  irq_polarity(irq_entry));
 #ifdef CONFIG_INTR_REMAP
 			else if (intr_remapping_enabled) {
-				*tgt_cpus = TARGET_CPUS;
+				TARGET_CPUS(*tgt_cpus);
 				set_ir_ioapic_affinity_irq_p(irq, tgt_cpus);
 			}
 #endif
 			else {
-				*tgt_cpus = TARGET_CPUS;
+				TARGET_CPUS(*tgt_cpus);
 				set_ioapic_affinity_irq_p(irq, tgt_cpus);
 			}
 		}
--- linux-2.6.tip.orig/include/asm-x86/genapic_64.h
+++ linux-2.6.tip/include/asm-x86/genapic_64.h
@@ -20,7 +20,7 @@ struct genapic {
 	u32 int_delivery_mode;
 	u32 int_dest_mode;
 	int (*apic_id_registered)(void);
-	cpumask_t (*target_cpus)(void);
+	void (*target_cpus)(cpumask_t *retmask);
 	cpumask_t (*vector_allocation_domain)(int cpu);
 	void (*init_apic_ldr)(void);
 	/* ipi */
--- linux-2.6.tip.orig/include/asm-x86/mach-default/mach_apic.h
+++ linux-2.6.tip/include/asm-x86/mach-default/mach_apic.h
@@ -7,24 +7,22 @@
 #include <asm/smp.h>
 
 #define APIC_DFR_VALUE	(APIC_DFR_FLAT)
+#define NO_BALANCE_IRQ (0)
+#define esr_disable (0)
 
-static inline cpumask_t target_cpus(void)
+#ifdef CONFIG_X86_64
+#include <asm/genapic.h>
+static inline void target_cpus(cpumask_t *retmask)
 { 
 #ifdef CONFIG_SMP
-	return cpu_online_map;
+	*retmask = cpu_online_map;
 #else
-	return cpumask_of_cpu(0);
+	*retmask = cpumask_of_cpu(0);
 #endif
 } 
-
-#define NO_BALANCE_IRQ (0)
-#define esr_disable (0)
-
-#ifdef CONFIG_X86_64
-#include <asm/genapic.h>
 #define INT_DELIVERY_MODE (genapic->int_delivery_mode)
 #define INT_DEST_MODE (genapic->int_dest_mode)
-#define TARGET_CPUS	  (genapic->target_cpus())
+#define TARGET_CPUS(retval) (genapic->target_cpus)(&(retval))
 #define apic_id_registered (genapic->apic_id_registered)
 #define init_apic_ldr (genapic->init_apic_ldr)
 #define cpu_mask_to_apicid (genapic->cpu_mask_to_apicid)
@@ -34,9 +32,17 @@ static inline cpumask_t target_cpus(void
 #define send_IPI_self (genapic->send_IPI_self)
 extern void setup_apic_routing(void);
 #else
+static inline cpumask_t target_cpus(void)
+{
+#ifdef CONFIG_SMP
+	return cpu_online_map;
+#else
+	return cpumask_of_cpu(0);
+#endif
+}
 #define INT_DELIVERY_MODE dest_LowestPrio
 #define INT_DEST_MODE 1     /* logical delivery broadcast to all procs */
-#define TARGET_CPUS (target_cpus())
+#define TARGET_CPUS(retval)	retval = (target_cpus())
 /*
  * Set up the logical destination ID.
  *
--- linux-2.6.tip.orig/include/asm-x86/mach-generic/mach_apic.h
+++ linux-2.6.tip/include/asm-x86/mach-generic/mach_apic.h
@@ -3,13 +3,17 @@
 
 #include <asm/genapic.h>
 
+#ifdef CONFIG_X86_64
+#define TARGET_CPUS(retval)	  (genapic->target_cpus)(&(retval))
+#else
+#define TARGET_CPUS(retval)	  retval = (genapic->target_cpus())
+#endif
 #define esr_disable (genapic->ESR_DISABLE)
 #define NO_BALANCE_IRQ (genapic->no_balance_irq)
 #define INT_DELIVERY_MODE (genapic->int_delivery_mode)
 #define INT_DEST_MODE (genapic->int_dest_mode)
 #undef APIC_DEST_LOGICAL
 #define APIC_DEST_LOGICAL (genapic->apic_destination_logical)
-#define TARGET_CPUS	  (genapic->target_cpus())
 #define apic_id_registered (genapic->apic_id_registered)
 #define init_apic_ldr (genapic->init_apic_ldr)
 #define ioapic_phys_id_map (genapic->ioapic_phys_id_map)

-- 

Re: [RFC 11/13] genapic: reduce stack pressuge in io_apic.c step 3 target_cpus

[Bert Wesarg]

On Sun, Sep 7, 2008 at 01:50, Mike Travis <travis@sgi.com> wrote:
>  * Step 3 "target_cpus" of cleaning up io_apic.c modifies the TARGET_CPUS
>    interface to pass a pointer to the returned mask for arch X86_64,
>    removing yet another "cpumask_t variable on the stack".
>
>        target_cpus = TARGET_CPUS;
>
>    becomes:
>
>        TARGET_CPUS(target_cpus);
>
>    For x86_32 this is expanded to:
>
>        target_cpus = (genapic->target_cpus());
>
>    For x86_64 this is expanded to:
>
>        target_cpus = (genapic->target_cpus)(&(target_cpus));
But its expended to:
         (genapic->target_cpus)(&(target_cpus));

> -#define TARGET_CPUS      (genapic->target_cpus())
> +#define TARGET_CPUS(retval) (genapic->target_cpus)(&(retval))


> +#ifdef CONFIG_X86_64
> +#define TARGET_CPUS(retval)      (genapic->target_cpus)(&(retval))
> +#else
> +#define TARGET_CPUS(retval)      retval = (genapic->target_cpus())
> +#endif

Bert

Re: [RFC 11/13] genapic: reduce stack pressuge in io_apic.c step 3 target_cpus

[Ingo Molnar]

> > +#ifdef CONFIG_X86_64
> > +#define TARGET_CPUS(retval)      (genapic->target_cpus)(&(retval))
> > +#else
> > +#define TARGET_CPUS(retval)      retval = (genapic->target_cpus())
> > +#endif

hm, this should be unified.

	Ingo

Re: [RFC 11/13] genapic: reduce stack pressuge in io_apic.c step 3 target_cpus

[Mike Travis]

Ingo Molnar wrote:
>>> +#ifdef CONFIG_X86_64
>>> +#define TARGET_CPUS(retval)      (genapic->target_cpus)(&(retval))
>>> +#else
>>> +#define TARGET_CPUS(retval)      retval = (genapic->target_cpus())
>>> +#endif
> 
> hm, this should be unified.
> 
> 	Ingo

As I did that one first, I didn't want to muddle through too much i386 code,
but when I did the vector_allocation_domain, it became more clear that making
them common would be better.

I also tripped myself up because one of my test i386 configs had 64 cpus and
it fired up the "NR_CPUS > BITS_PER_LON" code. ;-)  [And I'm supposing it's
probably justified to believe that there may be "fairly large" 32-bit systems,
for those applications that need horsepower but not a lot of memory.]

Thanks,
Mike

Re: [RFC 11/13] genapic: reduce stack pressuge in io_apic.c step 3 target_cpus

[Mike Travis]

Bert Wesarg wrote:
> On Sun, Sep 7, 2008 at 01:50, Mike Travis <travis@sgi.com> wrote:
>>  * Step 3 "target_cpus" of cleaning up io_apic.c modifies the TARGET_CPUS
>>    interface to pass a pointer to the returned mask for arch X86_64,
>>    removing yet another "cpumask_t variable on the stack".
>>
>>        target_cpus = TARGET_CPUS;
>>
>>    becomes:
>>
>>        TARGET_CPUS(target_cpus);
>>
>>    For x86_32 this is expanded to:
>>
>>        target_cpus = (genapic->target_cpus());
>>
>>    For x86_64 this is expanded to:
>>
>>        target_cpus = (genapic->target_cpus)(&(target_cpus));
> But its expended to:
>          (genapic->target_cpus)(&(target_cpus));

Umm, right, my cut and paste error...

Thanks,
Mike
> 
>> -#define TARGET_CPUS      (genapic->target_cpus())
>> +#define TARGET_CPUS(retval) (genapic->target_cpus)(&(retval))
> 
> 
>> +#ifdef CONFIG_X86_64
>> +#define TARGET_CPUS(retval)      (genapic->target_cpus)(&(retval))
>> +#else
>> +#define TARGET_CPUS(retval)      retval = (genapic->target_cpus())
>> +#endif
> 
> Bert

[RFC 12/13] genapic: reduce stack pressuge in io_apic.c step 4 vector allocation

[Mike Travis]

[-- Attachment #1: stack-hogs-io_apic_c-step-4-vector_allocation_domain --]
[-- Type: text/plain, Size: 9183 bytes --]

  * Step 4 "vector allocation" of cleaning up io_apic.c modifies the
    vector_allocation_domain genapic interface to pass a pointer to
    the returned mask removing yet another "cpumask_t variable on the stack".

	domain = vector_allocation_domain(cpu);

    becomes:

	vector_allocation_domain(cpu, &domain);

  * All the appropriate genapic "vector_allocation_domain" functions
    are modified to use this new interface.


Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/genapic_flat_64.c        |    9 ++++-----
 arch/x86/kernel/genx2apic_cluster.c      |    6 ++----
 arch/x86/kernel/genx2apic_phys.c         |    6 ++----
 arch/x86/kernel/genx2apic_uv_x.c         |    6 ++----
 arch/x86/kernel/io_apic.c                |    2 +-
 arch/x86/mach-generic/bigsmp.c           |    4 ++--
 arch/x86/mach-generic/es7000.c           |    5 ++---
 arch/x86/mach-generic/numaq.c            |    5 ++---
 arch/x86/mach-generic/summit.c           |    5 ++---
 include/asm-x86/genapic_32.h             |    4 ++--
 include/asm-x86/genapic_64.h             |    2 +-
 include/asm-x86/mach-default/mach_apic.h |    5 ++---
 12 files changed, 24 insertions(+), 35 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/genapic_flat_64.c
+++ linux-2.6.tip/arch/x86/kernel/genapic_flat_64.c
@@ -36,7 +36,7 @@ static void flat_target_cpus(cpumask_t *
 	*retmask = cpu_online_map;
 }
 
-static cpumask_t flat_vector_allocation_domain(int cpu)
+static void flat_vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
 	 * specified in the interrupt destination when using lowest
@@ -46,8 +46,7 @@ static cpumask_t flat_vector_allocation_
 	 * deliver interrupts to the wrong hyperthread when only one
 	 * hyperthread was specified in the interrupt desitination.
 	 */
-	cpumask_t domain = { { [0] = APIC_ALL_CPUS, } };
-	return domain;
+	*retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
 }
 
 /*
@@ -199,9 +198,9 @@ static void physflat_target_cpus(cpumask
 	*retmask = cpu_online_map;
 }
 
-static cpumask_t physflat_vector_allocation_domain(int cpu)
+static void physflat_vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
-	return cpumask_of_cpu(cpu);
+	*retmask = cpumask_of_cpu(cpu);
 }
 
 static void physflat_send_IPI_mask(const cpumask_t *cpumask, int vector)
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_cluster.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_cluster.c
@@ -31,11 +31,9 @@ static void x2apic_target_cpus(cpumask_t
 /*
  * for now each logical cpu is in its own vector allocation domain.
  */
-static cpumask_t x2apic_vector_allocation_domain(int cpu)
+static void x2apic_vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
-	cpumask_t domain = CPU_MASK_NONE;
-	cpu_set(cpu, domain);
-	return domain;
+	*retmask = cpumask_of_cpu(cpu);
 }
 
 static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_phys.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_phys.c
@@ -34,11 +34,9 @@ static void x2apic_target_cpus(cpumask_t
 	*retmask = cpumask_of_cpu(0);
 }
 
-static cpumask_t x2apic_vector_allocation_domain(int cpu)
+static void x2apic_vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
-	cpumask_t domain = CPU_MASK_NONE;
-	cpu_set(cpu, domain);
-	return domain;
+	*retmask = cpumask_of_cpu(cpu);
 }
 
 static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_uv_x.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_uv_x.c
@@ -82,11 +82,9 @@ static uv_target_cpus(cpumask_t *retmask
 	*retmask = cpumask_of_cpu(0);
 }
 
-static cpumask_t uv_vector_allocation_domain(int cpu)
+static void uv_vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
-	cpumask_t domain = CPU_MASK_NONE;
-	cpu_set(cpu, domain);
-	return domain;
+	*retmask = cpumask_of_cpu(cpu);
 }
 
 int uv_wakeup_secondary(int phys_apicid, unsigned int start_rip)
--- linux-2.6.tip.orig/arch/x86/kernel/io_apic.c
+++ linux-2.6.tip/arch/x86/kernel/io_apic.c
@@ -1292,7 +1292,7 @@ static int __assign_irq_vector(int irq, 
 		int new_cpu;
 		int vector, offset;
 
-		*tmpmask = vector_allocation_domain(cpu);
+		vector_allocation_domain(cpu, tmpmask);
 
 		vector = current_vector;
 		offset = current_offset;
--- linux-2.6.tip.orig/arch/x86/mach-generic/bigsmp.c
+++ linux-2.6.tip/arch/x86/mach-generic/bigsmp.c
@@ -41,9 +41,9 @@ static const struct dmi_system_id bigsmp
 	 { }
 };
 
-static cpumask_t vector_allocation_domain(int cpu)
+static void vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
-        return cpumask_of_cpu(cpu);
+	*retmask = cpumask_of_cpu(cpu);
 }
 
 static int probe_bigsmp(void)
--- linux-2.6.tip.orig/arch/x86/mach-generic/es7000.c
+++ linux-2.6.tip/arch/x86/mach-generic/es7000.c
@@ -65,7 +65,7 @@ static int __init acpi_madt_oem_check(ch
 }
 #endif
 
-static cpumask_t vector_allocation_domain(int cpu)
+static void vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
 	 * specified in the interrupt destination when using lowest
@@ -75,8 +75,7 @@ static cpumask_t vector_allocation_domai
 	 * deliver interrupts to the wrong hyperthread when only one
 	 * hyperthread was specified in the interrupt desitination.
 	 */
-	cpumask_t domain = { { [0] = APIC_ALL_CPUS, } };
-	return domain;
+	*retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
 }
 
 struct genapic __initdata_refok apic_es7000 = APIC_INIT("es7000", probe_es7000);
--- linux-2.6.tip.orig/arch/x86/mach-generic/numaq.c
+++ linux-2.6.tip/arch/x86/mach-generic/numaq.c
@@ -38,7 +38,7 @@ static int acpi_madt_oem_check(char *oem
 	return 0;
 }
 
-static cpumask_t vector_allocation_domain(int cpu)
+static void vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
 	 * specified in the interrupt destination when using lowest
@@ -48,8 +48,7 @@ static cpumask_t vector_allocation_domai
 	 * deliver interrupts to the wrong hyperthread when only one
 	 * hyperthread was specified in the interrupt desitination.
 	 */
-	cpumask_t domain = { { [0] = APIC_ALL_CPUS, } };
-	return domain;
+	*retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
 }
 
 struct genapic apic_numaq = APIC_INIT("NUMAQ", probe_numaq);
--- linux-2.6.tip.orig/arch/x86/mach-generic/summit.c
+++ linux-2.6.tip/arch/x86/mach-generic/summit.c
@@ -23,7 +23,7 @@ static int probe_summit(void)
 	return 0;
 }
 
-static cpumask_t vector_allocation_domain(int cpu)
+static void vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
 	/* Careful. Some cpus do not strictly honor the set of cpus
 	 * specified in the interrupt destination when using lowest
@@ -33,8 +33,7 @@ static cpumask_t vector_allocation_domai
 	 * deliver interrupts to the wrong hyperthread when only one
 	 * hyperthread was specified in the interrupt desitination.
 	 */
-	cpumask_t domain = { { [0] = APIC_ALL_CPUS, } };
-	return domain;
+	*retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
 }
 
 struct genapic apic_summit = APIC_INIT("summit", probe_summit);
--- linux-2.6.tip.orig/include/asm-x86/genapic_32.h
+++ linux-2.6.tip/include/asm-x86/genapic_32.h
@@ -58,7 +58,7 @@ struct genapic {
 	unsigned (*get_apic_id)(unsigned long x);
 	unsigned long apic_id_mask;
 	unsigned int (*cpu_mask_to_apicid)(cpumask_t cpumask);
-	cpumask_t (*vector_allocation_domain)(int cpu);
+	void (*vector_allocation_domain)(int cpu, cpumask_t *retmask);
 
 #ifdef CONFIG_SMP
 	/* ipi */
@@ -106,7 +106,7 @@ struct genapic {
 	APICFUNC(get_apic_id)				\
 	.apic_id_mask = APIC_ID_MASK,			\
 	APICFUNC(cpu_mask_to_apicid)			\
-	APICFUNC(vector_allocation_domain)			\
+	APICFUNC(vector_allocation_domain)		\
 	APICFUNC(acpi_madt_oem_check)			\
 	IPIFUNC(send_IPI_mask)				\
 	IPIFUNC(send_IPI_allbutself)			\
--- linux-2.6.tip.orig/include/asm-x86/genapic_64.h
+++ linux-2.6.tip/include/asm-x86/genapic_64.h
@@ -21,7 +21,7 @@ struct genapic {
 	u32 int_dest_mode;
 	int (*apic_id_registered)(void);
 	void (*target_cpus)(cpumask_t *retmask);
-	cpumask_t (*vector_allocation_domain)(int cpu);
+	void (*vector_allocation_domain)(int cpu, cpumask_t *retmask);
 	void (*init_apic_ldr)(void);
 	/* ipi */
 	void (*send_IPI_mask)(const cpumask_t *mask, int vector);
--- linux-2.6.tip.orig/include/asm-x86/mach-default/mach_apic.h
+++ linux-2.6.tip/include/asm-x86/mach-default/mach_apic.h
@@ -92,7 +92,7 @@ static inline int apicid_to_node(int log
 #endif
 }
 
-static inline cpumask_t vector_allocation_domain(int cpu)
+static inline void vector_allocation_domain(int cpu, cpumask_t *retmask)
 {
         /* Careful. Some cpus do not strictly honor the set of cpus
          * specified in the interrupt destination when using lowest
@@ -102,8 +102,7 @@ static inline cpumask_t vector_allocatio
          * deliver interrupts to the wrong hyperthread when only one
          * hyperthread was specified in the interrupt desitination.
          */
-        cpumask_t domain = { { [0] = APIC_ALL_CPUS, } };
-        return domain;
+        *retmask = (cpumask_t){ { [0] = APIC_ALL_CPUS, } };
 }
 #endif
 

-- 

[RFC 13/13] genapic: reduce stack pressuge in io_apic.c step 5 cpu_mask_to_apicid

[Mike Travis]

[-- Attachment #1: stack-hogs-io_apic_c-step-5-cpu_mask_to_apicid --]
[-- Type: text/plain, Size: 13470 bytes --]

  * Step 5 "cpu_mask_to_apicid" of cleaning up io_apic.c modifies the
    cpu_mask_to_apicid genapic interface to pass a pointer to incoming
    cpumask_t argument removing yet another "cpumask_t variable on the stack".

	apicid = cpu_mask_to_apicid(cpumask);

    becomes:

	apicid = cpu_mask_to_apicid(&cpumask);

  * All the appropriate genapic "cpu_mask_to_apicid" functions
    are modified to use this new interface.

  * Total stack savings are:

    ====== Stack (-l 100)

	1 - initial
	2 - stack-hogs-io_apic_c-step-1-temp-cpumask_ts
	3 - stack-hogs-io_apic_c-step-2-internal-abi
	4 - stack-hogs-io_apic_c-step-3-target_cpus
	5 - stack-hogs-io_apic_c-step-4-vector_allocation_domain
	6 - stack-hogs-io_apic_c-step-5-cpu_mask_to_apicid

       .1.    .2.   .3.   .4.    .5.   .6.    ..final..
      1576   -512     .  -512      .  -552   .  -100%  setup_IO_APIC_irq
      1560   -512     .  -528      .  -520   .  -100%  msi_compose_msg
      1560   -512     .  -512      .  -536   .  -100%  arch_setup_ht_irq
      1560  -1008     .     .   -552     .   .  -100%  __assign_irq_vector
      1144      .  -512  -632      .     .   .  -100%  setup_IO_APIC
      1048      .     .  -512      .  -536   .  -100%  setup_timer_IRQ0_pin
      1048      .  -512  -536      .     .   .  -100%  setup_ioapic_dest
      1048   -512  -536     .      .     .   .  -100%  set_ioapic_affinity_irq
      1040   -512     .     .      .  -528   .  -100%  set_msi_irq_affinity
      1040   -512     .     .      .  -528   .  -100%  set_ht_irq_affinity
      1040   -512     .     .      .  -528   .  -100%  dmar_msi_set_affinity
      1032     -8  -512  -512      .     .   .  -100%  create_irq_nr
      1024      .     .     .  -1024     .   .  -100%  x2apic_vector_allocation_domain
      1024      .     .     .  -1024     .   .  -100%  uv_vector_allocation_domain
       520   -520     .     .      .     .   .  -100%  __clear_irq_vector
       512   -512     .     .      .     .   .  -100%  irq_complete_move
       512      .  -512     .      .     .   .  -100%  assign_irq_vector
	 0      .  +536     .      .  -536   .      .  set_ioapic_affinity_irq_p
    18288 -5632 -2048 -3744 -2600 -4264   . -100%  Totals

Applies to linux-2.6.tip/master.

Signed-off-by: Mike Travis <travis@sgi.com>
---
 arch/x86/kernel/genapic_flat_64.c        |    8 ++++----
 arch/x86/kernel/genx2apic_cluster.c      |    4 ++--
 arch/x86/kernel/genx2apic_phys.c         |    4 ++--
 arch/x86/kernel/genx2apic_uv_x.c         |    4 ++--
 arch/x86/kernel/io_apic.c                |   20 ++++++++++----------
 include/asm-x86/bigsmp/apic.h            |    4 ++--
 include/asm-x86/es7000/apic.h            |    8 ++++----
 include/asm-x86/genapic_32.h             |    2 +-
 include/asm-x86/genapic_64.h             |    2 +-
 include/asm-x86/mach-default/mach_apic.h |    4 ++--
 include/asm-x86/numaq/apic.h             |    2 +-
 include/asm-x86/summit/apic.h            |    8 ++++----
 12 files changed, 35 insertions(+), 35 deletions(-)

--- linux-2.6.tip.orig/arch/x86/kernel/genapic_flat_64.c
+++ linux-2.6.tip/arch/x86/kernel/genapic_flat_64.c
@@ -140,9 +140,9 @@ static int flat_apic_id_registered(void)
 	return physid_isset(read_xapic_id(), phys_cpu_present_map);
 }
 
-static unsigned int flat_cpu_mask_to_apicid(cpumask_t cpumask)
+static unsigned int flat_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
-	return cpus_addr(cpumask)[0] & APIC_ALL_CPUS;
+	return cpus_addr(*cpumask)[0] & APIC_ALL_CPUS;
 }
 
 static unsigned int phys_pkg_id(int index_msb)
@@ -227,7 +227,7 @@ static void physflat_send_IPI_all(int ve
 	physflat_send_IPI_mask(&cpu_online_map, vector);
 }
 
-static unsigned int physflat_cpu_mask_to_apicid(cpumask_t cpumask)
+static unsigned int physflat_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int cpu;
 
@@ -235,7 +235,7 @@ static unsigned int physflat_cpu_mask_to
 	 * We're using fixed IRQ delivery, can only return one phys APIC ID.
 	 * May as well be the first.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	if ((unsigned)cpu < nr_cpu_ids)
 		return per_cpu(x86_cpu_to_apicid, cpu);
 	else
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_cluster.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_cluster.c
@@ -92,7 +92,7 @@ static int x2apic_apic_id_registered(voi
 	return 1;
 }
 
-static unsigned int x2apic_cpu_mask_to_apicid(cpumask_t cpumask)
+static unsigned int x2apic_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int cpu;
 
@@ -100,7 +100,7 @@ static unsigned int x2apic_cpu_mask_to_a
 	 * We're using fixed IRQ delivery, can only return one phys APIC ID.
 	 * May as well be the first.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	if ((unsigned)cpu < NR_CPUS)
 		return per_cpu(x86_cpu_to_logical_apicid, cpu);
 	else
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_phys.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_phys.c
@@ -85,7 +85,7 @@ static int x2apic_apic_id_registered(voi
 	return 1;
 }
 
-static unsigned int x2apic_cpu_mask_to_apicid(cpumask_t cpumask)
+static unsigned int x2apic_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int cpu;
 
@@ -93,7 +93,7 @@ static unsigned int x2apic_cpu_mask_to_a
 	 * We're using fixed IRQ delivery, can only return one phys APIC ID.
 	 * May as well be the first.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	if ((unsigned)cpu < NR_CPUS)
 		return per_cpu(x86_cpu_to_apicid, cpu);
 	else
--- linux-2.6.tip.orig/arch/x86/kernel/genx2apic_uv_x.c
+++ linux-2.6.tip/arch/x86/kernel/genx2apic_uv_x.c
@@ -160,7 +160,7 @@ static void uv_init_apic_ldr(void)
 {
 }
 
-static unsigned int uv_cpu_mask_to_apicid(cpumask_t cpumask)
+static unsigned int uv_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int cpu;
 
@@ -168,7 +168,7 @@ static unsigned int uv_cpu_mask_to_apici
 	 * We're using fixed IRQ delivery, can only return one phys APIC ID.
 	 * May as well be the first.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	if ((unsigned)cpu < nr_cpu_ids)
 		return per_cpu(x86_cpu_to_apicid, cpu);
 	else
--- linux-2.6.tip.orig/arch/x86/kernel/io_apic.c
+++ linux-2.6.tip/arch/x86/kernel/io_apic.c
@@ -602,7 +602,7 @@ static void set_ioapic_affinity_irq_p(un
 	}
 
 	cpus_and(*tmp, cfg->domain, *mask);
-	dest = cpu_mask_to_apicid(*tmp);
+	dest = cpu_mask_to_apicid(tmp);
 	/*
 	 * Only the high 8 bits are valid.
 	 */
@@ -1546,7 +1546,7 @@ static void setup_IO_APIC_irq(int apic, 
 
 
 	if (setup_ioapic_entry(mp_ioapics[apic].mp_apicid, irq, &entry,
-			       cpu_mask_to_apicid(*mask), trigger, polarity,
+			       cpu_mask_to_apicid(mask), trigger, polarity,
 			       cfg->vector)) {
 		printk("Failed to setup ioapic entry for ioapic  %d, pin %d\n",
 		       mp_ioapics[apic].mp_apicid, pin);
@@ -1626,7 +1626,7 @@ static void __init setup_timer_IRQ0_pin(
 	 */
 	entry.dest_mode = INT_DEST_MODE;
 	entry.mask = 1;					/* mask IRQ now */
-	entry.dest = cpu_mask_to_apicid(*tgt_cpus);
+	entry.dest = cpu_mask_to_apicid(tgt_cpus);
 	entry.delivery_mode = INT_DELIVERY_MODE;
 	entry.polarity = 0;
 	entry.trigger = 0;
@@ -2322,7 +2322,7 @@ static void migrate_ioapic_irq(int irq, 
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tmpmask, cfg->domain, *mask);
-	dest = cpu_mask_to_apicid(*tmpmask);
+	dest = cpu_mask_to_apicid(tmpmask);
 
 	desc = irq_to_desc(irq);
 	modify_ioapic_rte = desc->status & IRQ_LEVEL;
@@ -3204,7 +3204,7 @@ static int msi_compose_msg(struct pci_de
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tgt_cpus, cfg->domain, *tgt_cpus);
-	dest = cpu_mask_to_apicid(*tgt_cpus);
+	dest = cpu_mask_to_apicid(tgt_cpus);
 	put_cpumask_var(tgt_cpus, cpumask_irq_level_4);
 
 #ifdef CONFIG_INTR_REMAP
@@ -3277,7 +3277,7 @@ static void set_msi_irq_affinity(unsigne
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(*tmp);
+	dest = cpu_mask_to_apicid(tmp);
 
 	read_msi_msg(irq, &msg);
 
@@ -3319,7 +3319,7 @@ static void ir_set_msi_irq_affinity(unsi
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(*tmp);
+	dest = cpu_mask_to_apicid(tmp);
 
 	irte.vector = cfg->vector;
 	irte.dest_id = IRTE_DEST(dest);
@@ -3561,7 +3561,7 @@ static void dmar_msi_set_affinity(unsign
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(*tmp);
+	dest = cpu_mask_to_apicid(tmp);
 
 	dmar_msi_read(irq, &msg);
 
@@ -3643,7 +3643,7 @@ static void set_ht_irq_affinity(unsigned
 
 	cfg = irq_cfg(irq);
 	cpus_and(*tmp, cfg->domain, mask);
-	dest = cpu_mask_to_apicid(*tmp);
+	dest = cpu_mask_to_apicid(tmp);
 
 	target_ht_irq(irq, dest, cfg->vector);
 	desc = irq_to_desc(irq);
@@ -3679,7 +3679,7 @@ int arch_setup_ht_irq(unsigned int irq, 
 
 		cfg = irq_cfg(irq);
 		cpus_and(*tgt_cpus, cfg->domain, *tgt_cpus);
-		dest = cpu_mask_to_apicid(*tgt_cpus);
+		dest = cpu_mask_to_apicid(tgt_cpus);
 
 		msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
 
--- linux-2.6.tip.orig/include/asm-x86/bigsmp/apic.h
+++ linux-2.6.tip/include/asm-x86/bigsmp/apic.h
@@ -121,12 +121,12 @@ static inline int check_phys_apicid_pres
 }
 
 /* As we are using single CPU as destination, pick only one CPU here */
-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
+static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int cpu;
 	int apicid;	
 
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	apicid = cpu_to_logical_apicid(cpu);
 	return apicid;
 }
--- linux-2.6.tip.orig/include/asm-x86/es7000/apic.h
+++ linux-2.6.tip/include/asm-x86/es7000/apic.h
@@ -144,14 +144,14 @@ static inline int check_phys_apicid_pres
 	return (1);
 }
 
-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
+static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int num_bits_set;
 	int cpus_found = 0;
 	int cpu;
 	int apicid;
 
-	num_bits_set = cpus_weight(cpumask);
+	num_bits_set = cpus_weight(*cpumask);
 	/* Return id to all */
 	if (num_bits_set == NR_CPUS)
 #if defined CONFIG_ES7000_CLUSTERED_APIC
@@ -163,10 +163,10 @@ static inline unsigned int cpu_mask_to_a
 	 * The cpus in the mask must all be on the apic cluster.  If are not
 	 * on the same apicid cluster return default value of TARGET_CPUS.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	apicid = cpu_to_logical_apicid(cpu);
 	while (cpus_found < num_bits_set) {
-		if (cpu_isset(cpu, cpumask)) {
+		if (cpu_isset(cpu, *cpumask)) {
 			int new_apicid = cpu_to_logical_apicid(cpu);
 			if (apicid_cluster(apicid) !=
 					apicid_cluster(new_apicid)){
--- linux-2.6.tip.orig/include/asm-x86/genapic_32.h
+++ linux-2.6.tip/include/asm-x86/genapic_32.h
@@ -57,7 +57,7 @@ struct genapic {
 
 	unsigned (*get_apic_id)(unsigned long x);
 	unsigned long apic_id_mask;
-	unsigned int (*cpu_mask_to_apicid)(cpumask_t cpumask);
+	unsigned int (*cpu_mask_to_apicid)(const cpumask_t *cpumask);
 	void (*vector_allocation_domain)(int cpu, cpumask_t *retmask);
 
 #ifdef CONFIG_SMP
--- linux-2.6.tip.orig/include/asm-x86/genapic_64.h
+++ linux-2.6.tip/include/asm-x86/genapic_64.h
@@ -29,7 +29,7 @@ struct genapic {
 	void (*send_IPI_all)(int vector);
 	void (*send_IPI_self)(int vector);
 	/* */
-	unsigned int (*cpu_mask_to_apicid)(cpumask_t cpumask);
+	unsigned int (*cpu_mask_to_apicid)(const cpumask_t *cpumask);
 	unsigned int (*phys_pkg_id)(int index_msb);
 	unsigned int (*get_apic_id)(unsigned long x);
 	unsigned long (*set_apic_id)(unsigned int id);
--- linux-2.6.tip.orig/include/asm-x86/mach-default/mach_apic.h
+++ linux-2.6.tip/include/asm-x86/mach-default/mach_apic.h
@@ -65,9 +65,9 @@ static inline int apic_id_registered(voi
 	return physid_isset(read_apic_id(), phys_cpu_present_map);
 }
 
-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
+static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
-	return cpus_addr(cpumask)[0];
+	return cpus_addr(*cpumask)[0];
 }
 
 static inline u32 phys_pkg_id(u32 cpuid_apic, int index_msb)
--- linux-2.6.tip.orig/include/asm-x86/numaq/apic.h
+++ linux-2.6.tip/include/asm-x86/numaq/apic.h
@@ -122,7 +122,7 @@ static inline void enable_apic_mode(void
  * We use physical apicids here, not logical, so just return the default
  * physical broadcast to stop people from breaking us
  */
-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
+static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	return (int) 0xF;
 }
--- linux-2.6.tip.orig/include/asm-x86/summit/apic.h
+++ linux-2.6.tip/include/asm-x86/summit/apic.h
@@ -137,14 +137,14 @@ static inline void enable_apic_mode(void
 {
 }
 
-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
+static inline unsigned int cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
 	int num_bits_set;
 	int cpus_found = 0;
 	int cpu;
 	int apicid;
 
-	num_bits_set = cpus_weight(cpumask);
+	num_bits_set = cpus_weight(*cpumask);
 	/* Return id to all */
 	if (num_bits_set == NR_CPUS)
 		return (int) 0xFF;
@@ -152,10 +152,10 @@ static inline unsigned int cpu_mask_to_a
 	 * The cpus in the mask must all be on the apic cluster.  If are not
 	 * on the same apicid cluster return default value of TARGET_CPUS.
 	 */
-	cpu = first_cpu(cpumask);
+	cpu = first_cpu(*cpumask);
 	apicid = cpu_to_logical_apicid(cpu);
 	while (cpus_found < num_bits_set) {
-		if (cpu_isset(cpu, cpumask)) {
+		if (cpu_isset(cpu, *cpumask)) {
 			int new_apicid = cpu_to_logical_apicid(cpu);
 			if (apicid_cluster(apicid) !=
 					apicid_cluster(new_apicid)){

-- 

Re: [RFC 00/13] smp: reduce stack requirements for genapic send_IPI_mask functions

[Ingo Molnar]

* Mike Travis <travis@sgi.com> wrote:

> [Note: all these changes require some more testing but I wanted to 
> solicit comments before then, hence the "RFC" in the subject line. 
> -thanks! Mike]

these changes are certainly looking very nice.

They do interact with a ton of high-flux topics in -tip, so i'd prefer 
to start integrating/testing this straight away (today-ish), before the 
target moves yet again. Are there any showstoppers that speak against 
that?

The plan would be to not keep this in a single topic but to spread them 
into their closest topic (tip/x86/x2apic, tip/irq/sparseirq etc.) - are 
there any cross-topic dependencies to be careful about? Most of the 
commits seem to be standalone. The debug patch would go into 
tip/cpus4096.

And more generally: how far away are we from being able to introduce 
struct cpumask and hide its implementation from most .c files? That 
would be rather efficient in preventing it from being put on the stack 
spuriously in one of the 30+ thousand Linux kernel source code files. 
Just like we hide the true structure of things like 'struct kmem_cache' 
and force them to always be used as pointers.

	Ingo

Re: [RFC 00/13] smp: reduce stack requirements for genapic send_IPI_mask functions

[Mike Travis]

Ingo Molnar wrote:
> * Mike Travis <travis@sgi.com> wrote:
> 
>> [Note: all these changes require some more testing but I wanted to 
>> solicit comments before then, hence the "RFC" in the subject line. 
>> -thanks! Mike]
> 
> these changes are certainly looking very nice.
> 
> They do interact with a ton of high-flux topics in -tip, so i'd prefer 
> to start integrating/testing this straight away (today-ish), before the 
> target moves yet again. Are there any showstoppers that speak against 
> that?
> 
> The plan would be to not keep this in a single topic but to spread them 
> into their closest topic (tip/x86/x2apic, tip/irq/sparseirq etc.) - are 
> there any cross-topic dependencies to be careful about? Most of the 
> commits seem to be standalone. The debug patch would go into 
> tip/cpus4096.
> 
> And more generally: how far away are we from being able to introduce 
> struct cpumask and hide its implementation from most .c files? That 
> would be rather efficient in preventing it from being put on the stack 
> spuriously in one of the 30+ thousand Linux kernel source code files. 
> Just like we hide the true structure of things like 'struct kmem_cache' 
> and force them to always be used as pointers.
> 
> 	Ingo

What I'll do is resubmit the changes that have nothing to do with
cpumask_ptr's first as they are mostly just "cleaning up extraneous
temp cpumask variables".  Then I'll try the redefine of cpumask_t to
see what kind of hornet's nest is opened up.

What do you think of a pool of temp cpumask_t's?  That way, they
could be made available early (before kmalloc is available).  An
atomic op could be used for reservation which when the zero-based
percpu variables finally get completed, become very low cost.

Thanks,
Mike