From de4d1db369785c29d68915edfee0cb70e8199f4c Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Wed, 21 Nov 2007 22:02:58 +0800 Subject: [LIB]: Introduce struct pcounter This just generalises what was introduced by Eric Dumazet for the struct proto inuse field in 286ab3d46058840d68e5d7d52e316c1f7e98c59f: [NET]: Define infrastructure to keep 'inuse' changes in an efficent SMP/NUMA way. Please look at the comment in there to see the rationale. Signed-off-by: Arnaldo Carvalho de Melo Signed-off-by: Herbert Xu Signed-off-by: David S. Miller --- lib/Makefile | 1 + lib/pcounter.c | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 lib/pcounter.c (limited to 'lib') diff --git a/lib/Makefile b/lib/Makefile index 89841dc9d91c..543f2502b60a 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -61,6 +61,7 @@ obj-$(CONFIG_TEXTSEARCH_KMP) += ts_kmp.o obj-$(CONFIG_TEXTSEARCH_BM) += ts_bm.o obj-$(CONFIG_TEXTSEARCH_FSM) += ts_fsm.o obj-$(CONFIG_SMP) += percpu_counter.o +obj-$(CONFIG_SMP) += pcounter.o obj-$(CONFIG_AUDIT_GENERIC) += audit.o obj-$(CONFIG_SWIOTLB) += swiotlb.o diff --git a/lib/pcounter.c b/lib/pcounter.c new file mode 100644 index 000000000000..93feea598251 --- /dev/null +++ b/lib/pcounter.c @@ -0,0 +1,26 @@ +/* + * Define default pcounter functions + * Note that often used pcounters use dedicated functions to get a speed increase. + * (see DEFINE_PCOUNTER/REF_PCOUNTER_MEMBER) + */ + +#include +#include +#include + +void pcounter_def_add(struct pcounter *self, int inc) +{ + per_cpu_ptr(self->per_cpu_values, smp_processor_id())[0] += inc; +} + +EXPORT_SYMBOL_GPL(pcounter_def_add); + +int pcounter_def_getval(const struct pcounter *self) +{ + int res = 0, cpu; + for_each_possible_cpu(cpu) + res += per_cpu_ptr(self->per_cpu_values, cpu)[0]; + return res; +} + +EXPORT_SYMBOL_GPL(pcounter_def_getval); -- cgit v1.2.3 From 571e7682026fd0e25833d103a3eeb74be29bf199 Mon Sep 17 00:00:00 2001 From: Eric Dumazet Date: Thu, 3 Jan 2008 20:41:28 -0800 Subject: [LIB] pcounter : unline too big functions Before pushing pcounter to Linus tree, I would like to make some adjustments. Goal is to reduce kernel text size, by unlining too big functions. When a pcounter is bound to a statically defined per_cpu variable, we define two small helpers functions. (No more folding function using the fat for_each_possible_cpu(cpu) ... ) static DEFINE_PER_CPU(int, NAME##_pcounter_values); static void NAME##_pcounter_add(struct pcounter *self, int val) { __get_cpu_var(NAME##_pcounter_values) += val; } static int NAME##_pcounter_getval(const struct pcounter *self, int cpu) { return per_cpu(NAME##_pcounter_values, cpu); } Fast path is therefore unchanged, while folding/alloc/free is now unlined. This saves 228 bytes on i386 Signed-off-by: Eric Dumazet Signed-off-by: David S. Miller --- include/linux/pcounter.h | 80 ++++++++++++++++-------------------------------- lib/pcounter.c | 42 ++++++++++++++++++++++--- 2 files changed, 63 insertions(+), 59 deletions(-) (limited to 'lib') diff --git a/include/linux/pcounter.h b/include/linux/pcounter.h index 9c4760a328f3..a82d9f2628ca 100644 --- a/include/linux/pcounter.h +++ b/include/linux/pcounter.h @@ -1,41 +1,39 @@ #ifndef __LINUX_PCOUNTER_H #define __LINUX_PCOUNTER_H - +/* + * Using a dynamic percpu 'int' variable has a cost : + * 1) Extra dereference + * Current per_cpu_ptr() implementation uses an array per 'percpu variable'. + * 2) memory cost of NR_CPUS*(32+sizeof(void *)) instead of num_possible_cpus()*4 + * + * This pcounter implementation is an abstraction to be able to use + * either a static or a dynamic per cpu variable. + * One dynamic per cpu variable gets a fast & cheap implementation, we can + * change pcounter implementation too. + */ struct pcounter { #ifdef CONFIG_SMP void (*add)(struct pcounter *self, int inc); - int (*getval)(const struct pcounter *self); + int (*getval)(const struct pcounter *self, int cpu); int *per_cpu_values; #else int val; #endif }; -/* - * Special macros to let pcounters use a fast version of {getvalue|add} - * using a static percpu variable per pcounter instead of an allocated one, - * saving one dereference. - * This might be changed if/when dynamic percpu vars become fast. - */ #ifdef CONFIG_SMP -#include #include -#define DEFINE_PCOUNTER(NAME) \ -static DEFINE_PER_CPU(int, NAME##_pcounter_values); \ -static void NAME##_pcounter_add(struct pcounter *self, int inc) \ -{ \ - __get_cpu_var(NAME##_pcounter_values) += inc; \ -} \ - \ -static int NAME##_pcounter_getval(const struct pcounter *self) \ -{ \ - int res = 0, cpu; \ - \ - for_each_possible_cpu(cpu) \ - res += per_cpu(NAME##_pcounter_values, cpu); \ - return res; \ -} +#define DEFINE_PCOUNTER(NAME) \ +static DEFINE_PER_CPU(int, NAME##_pcounter_values); \ +static void NAME##_pcounter_add(struct pcounter *self, int val) \ +{ \ + __get_cpu_var(NAME##_pcounter_values) += val; \ +} \ +static int NAME##_pcounter_getval(const struct pcounter *self, int cpu) \ +{ \ + return per_cpu(NAME##_pcounter_values, cpu); \ +} \ #define PCOUNTER_MEMBER_INITIALIZER(NAME, MEMBER) \ MEMBER = { \ @@ -43,42 +41,16 @@ static int NAME##_pcounter_getval(const struct pcounter *self) \ .getval = NAME##_pcounter_getval, \ } -extern void pcounter_def_add(struct pcounter *self, int inc); -extern int pcounter_def_getval(const struct pcounter *self); - -static inline int pcounter_alloc(struct pcounter *self) -{ - int rc = 0; - if (self->add == NULL) { - self->per_cpu_values = alloc_percpu(int); - if (self->per_cpu_values != NULL) { - self->add = pcounter_def_add; - self->getval = pcounter_def_getval; - } else - rc = 1; - } - return rc; -} - -static inline void pcounter_free(struct pcounter *self) -{ - if (self->per_cpu_values != NULL) { - free_percpu(self->per_cpu_values); - self->per_cpu_values = NULL; - self->getval = NULL; - self->add = NULL; - } -} static inline void pcounter_add(struct pcounter *self, int inc) { self->add(self, inc); } -static inline int pcounter_getval(const struct pcounter *self) -{ - return self->getval(self); -} +extern int pcounter_getval(const struct pcounter *self); +extern int pcounter_alloc(struct pcounter *self); +extern void pcounter_free(struct pcounter *self); + #else /* CONFIG_SMP */ diff --git a/lib/pcounter.c b/lib/pcounter.c index 93feea598251..9b56807da93b 100644 --- a/lib/pcounter.c +++ b/lib/pcounter.c @@ -7,20 +7,52 @@ #include #include #include +#include -void pcounter_def_add(struct pcounter *self, int inc) +static void pcounter_dyn_add(struct pcounter *self, int inc) { per_cpu_ptr(self->per_cpu_values, smp_processor_id())[0] += inc; } -EXPORT_SYMBOL_GPL(pcounter_def_add); +static int pcounter_dyn_getval(const struct pcounter *self, int cpu) +{ + return per_cpu_ptr(self->per_cpu_values, cpu)[0]; +} -int pcounter_def_getval(const struct pcounter *self) +int pcounter_getval(const struct pcounter *self) { int res = 0, cpu; + for_each_possible_cpu(cpu) - res += per_cpu_ptr(self->per_cpu_values, cpu)[0]; + res += self->getval(self, cpu); + return res; } +EXPORT_SYMBOL_GPL(pcounter_getval); + +int pcounter_alloc(struct pcounter *self) +{ + int rc = 0; + if (self->add == NULL) { + self->per_cpu_values = alloc_percpu(int); + if (self->per_cpu_values != NULL) { + self->add = pcounter_dyn_add; + self->getval = pcounter_dyn_getval; + } else + rc = 1; + } + return rc; +} +EXPORT_SYMBOL_GPL(pcounter_alloc); + +void pcounter_free(struct pcounter *self) +{ + if (self->per_cpu_values != NULL) { + free_percpu(self->per_cpu_values); + self->per_cpu_values = NULL; + self->getval = NULL; + self->add = NULL; + } +} +EXPORT_SYMBOL_GPL(pcounter_free); -EXPORT_SYMBOL_GPL(pcounter_def_getval); -- cgit v1.2.3