<feed xmlns='http://www.w3.org/2005/Atom'>
<title>user/sven/linux.git/include/linux/slub_def.h, branch v2.6.34.6</title>
<subtitle>Linux Kernel
</subtitle>
<id>https://git.stealer.net/cgit.cgi/user/sven/linux.git/atom?h=v2.6.34.6</id>
<link rel='self' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/atom?h=v2.6.34.6'/>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/'/>
<updated>2010-07-05T18:22:37Z</updated>
<entry>
<title>slub: move kmem_cache_node into it's own cacheline</title>
<updated>2010-07-05T18:22:37Z</updated>
<author>
<name>Alexander Duyck</name>
<email>alexander.h.duyck@intel.com</email>
</author>
<published>2010-05-21T21:41:35Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=68b99fb8e1e21209c9cad878e99947613e445777'/>
<id>urn:sha1:68b99fb8e1e21209c9cad878e99947613e445777</id>
<content type='text'>
commit 73367bd8eef4f4eb311005886aaa916013073265 upstream.

This patch is meant to improve the performance of SLUB by moving the local
kmem_cache_node lock into it's own cacheline separate from kmem_cache.
This is accomplished by simply removing the local_node when NUMA is enabled.

On my system with 2 nodes I saw around a 5% performance increase w/
hackbench times dropping from 6.2 seconds to 5.9 seconds on average.  I
suspect the performance gain would increase as the number of nodes
increases, but I do not have the data to currently back that up.

Bugzilla-Reference: http://bugzilla.kernel.org/show_bug.cgi?id=15713
Reported-by: Alex Shi &lt;alex.shi@intel.com&gt;
Tested-by: Alex Shi &lt;alex.shi@intel.com&gt;
Acked-by: Yanmin Zhang &lt;yanmin_zhang@linux.intel.com&gt;
Acked-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Alexander Duyck &lt;alexander.h.duyck@intel.com&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@suse.de&gt;

</content>
</entry>
<entry>
<title>SLUB: Allow full duplication of kmalloc array for 390</title>
<updated>2010-07-05T18:22:37Z</updated>
<author>
<name>Christoph Lameter</name>
<email>cl@linux-foundation.org</email>
</author>
<published>2010-05-27T14:17:17Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=0d28a228f4fc8d88deaafa4c284385271a84da5c'/>
<id>urn:sha1:0d28a228f4fc8d88deaafa4c284385271a84da5c</id>
<content type='text'>
commit 0f1f694260e0d35b5ce7d471f6e679c3dd4d7d94 upstream.

Commit 756dee75872a2a764b478e18076360b8a4ec9045 ("SLUB: Get rid of dynamic DMA
kmalloc cache allocation") makes S390 run out of kmalloc caches.  Increase the
number of kmalloc caches to a safe size.

Reported-by: Heiko Carstens &lt;heiko.carstens@de.ibm.com&gt;
Tested-by: Heiko Carstens &lt;heiko.carstens@de.ibm.com&gt;
Signed-off-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@suse.de&gt;

</content>
</entry>
<entry>
<title>SLUB: this_cpu: Remove slub kmem_cache fields</title>
<updated>2009-12-20T08:17:59Z</updated>
<author>
<name>Christoph Lameter</name>
<email>cl@linux-foundation.org</email>
</author>
<published>2009-12-18T22:26:22Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=ff12059ed14b0773d7bbef86f98218ada6c20770'/>
<id>urn:sha1:ff12059ed14b0773d7bbef86f98218ada6c20770</id>
<content type='text'>
Remove the fields in struct kmem_cache_cpu that were used to cache data from
struct kmem_cache when they were in different cachelines. The cacheline that
holds the per cpu array pointer now also holds these values. We can cut down
the struct kmem_cache_cpu size to almost half.

The get_freepointer() and set_freepointer() functions that used to be only
intended for the slow path now are also useful for the hot path since access
to the size field does not require accessing an additional cacheline anymore.
This results in consistent use of functions for setting the freepointer of
objects throughout SLUB.

Also we initialize all possible kmem_cache_cpu structures when a slab is
created. No need to initialize them when a processor or node comes online.

Signed-off-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
<entry>
<title>SLUB: Get rid of dynamic DMA kmalloc cache allocation</title>
<updated>2009-12-20T07:57:00Z</updated>
<author>
<name>Christoph Lameter</name>
<email>cl@linux-foundation.org</email>
</author>
<published>2009-12-18T22:26:21Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=756dee75872a2a764b478e18076360b8a4ec9045'/>
<id>urn:sha1:756dee75872a2a764b478e18076360b8a4ec9045</id>
<content type='text'>
Dynamic DMA kmalloc cache allocation is troublesome since the
new percpu allocator does not support allocations in atomic contexts.
Reserve some statically allocated kmalloc_cpu structures instead.

Signed-off-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
<entry>
<title>SLUB: Use this_cpu operations in slub</title>
<updated>2009-12-20T07:29:18Z</updated>
<author>
<name>Christoph Lameter</name>
<email>cl@linux-foundation.org</email>
</author>
<published>2009-12-18T22:26:20Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=9dfc6e68bfe6ee452efb1a4e9ca26a9007f2b864'/>
<id>urn:sha1:9dfc6e68bfe6ee452efb1a4e9ca26a9007f2b864</id>
<content type='text'>
Using per cpu allocations removes the needs for the per cpu arrays in the
kmem_cache struct. These could get quite big if we have to support systems
with thousands of cpus. The use of this_cpu_xx operations results in:

1. The size of kmem_cache for SMP configuration shrinks since we will only
   need 1 pointer instead of NR_CPUS. The same pointer can be used by all
   processors. Reduces cache footprint of the allocator.

2. We can dynamically size kmem_cache according to the actual nodes in the
   system meaning less memory overhead for configurations that may potentially
   support up to 1k NUMA nodes / 4k cpus.

3. We can remove the diddle widdle with allocating and releasing of
   kmem_cache_cpu structures when bringing up and shutting down cpus. The cpu
   alloc logic will do it all for us. Removes some portions of the cpu hotplug
   functionality.

4. Fastpath performance increases since per cpu pointer lookups and
   address calculations are avoided.

V7-V8
- Convert missed get_cpu_slab() under CONFIG_SLUB_STATS

Signed-off-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
<entry>
<title>tracing, slab: Define kmem_cache_alloc_notrace ifdef CONFIG_TRACING</title>
<updated>2009-12-11T08:17:02Z</updated>
<author>
<name>Li Zefan</name>
<email>lizf@cn.fujitsu.com</email>
</author>
<published>2009-12-11T07:45:30Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=0f24f1287a86b198c1e4bd4ce45e8565e40ff804'/>
<id>urn:sha1:0f24f1287a86b198c1e4bd4ce45e8565e40ff804</id>
<content type='text'>
Define kmem_trace_alloc_{,node}_notrace() if CONFIG_TRACING is
enabled, otherwise perf-kmem will show wrong stats ifndef
CONFIG_KMEM_TRACE, because a kmalloc() memory allocation may
be traced by both trace_kmalloc() and trace_kmem_cache_alloc().

Signed-off-by: Li Zefan &lt;lizf@cn.fujitsu.com&gt;
Reviewed-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
Cc: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Cc: Steven Rostedt &lt;rostedt@goodmis.org&gt;
Cc: Frederic Weisbecker &lt;fweisbec@gmail.com&gt;
Cc: linux-mm@kvack.org &lt;linux-mm@kvack.org&gt;
Cc: Eduard - Gabriel Munteanu &lt;eduard.munteanu@linux360.ro&gt;
LKML-Reference: &lt;4B21F89A.7000801@cn.fujitsu.com&gt;
Signed-off-by: Ingo Molnar &lt;mingo@elte.hu&gt;
</content>
</entry>
<entry>
<title>Merge branches 'slab/cleanups' and 'slab/fixes' into for-linus</title>
<updated>2009-09-14T17:19:06Z</updated>
<author>
<name>Pekka Enberg</name>
<email>penberg@cs.helsinki.fi</email>
</author>
<published>2009-09-14T17:19:06Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=aceda773606f2506a25b91aaafae87b2e4315834'/>
<id>urn:sha1:aceda773606f2506a25b91aaafae87b2e4315834</id>
<content type='text'>
</content>
</entry>
<entry>
<title>SLUB: fix ARCH_KMALLOC_MINALIGN cases 64 and 256</title>
<updated>2009-08-30T11:56:48Z</updated>
<author>
<name>Aaro Koskinen</name>
<email>aaro.koskinen@nokia.com</email>
</author>
<published>2009-08-28T11:28:54Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=acdfcd04d9df7d084ff752f82afad6ed4ad5f363'/>
<id>urn:sha1:acdfcd04d9df7d084ff752f82afad6ed4ad5f363</id>
<content type='text'>
If the minalign is 64 bytes, then the 96 byte cache should not be created
because it would conflict with the 128 byte cache.

If the minalign is 256 bytes, patching the size_index table should not
result in a buffer overrun.

The calculation "(i - 1) / 8" used to access size_index[] is moved to
a separate function as suggested by Christoph Lameter.

Acked-by: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Aaro Koskinen &lt;aaro.koskinen@nokia.com&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
<entry>
<title>slab: remove duplicate kmem_cache_init_late() declarations</title>
<updated>2009-08-06T08:36:25Z</updated>
<author>
<name>Wu Fengguang</name>
<email>fengguang.wu@intel.com</email>
</author>
<published>2009-08-06T08:36:25Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=bbff2e433e80fae72c8d00d482927d52ec19ba33'/>
<id>urn:sha1:bbff2e433e80fae72c8d00d482927d52ec19ba33</id>
<content type='text'>
kmem_cache_init_late() has been declared in slab.h

CC: Nick Piggin &lt;npiggin@suse.de&gt;
CC: Matt Mackall &lt;mpm@selenic.com&gt;
CC: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Signed-off-by: Wu Fengguang &lt;fengguang.wu@intel.com&gt;
Signed-off-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
<entry>
<title>kmemleak: Trace the kmalloc_large* functions in slub</title>
<updated>2009-07-08T13:25:14Z</updated>
<author>
<name>Catalin Marinas</name>
<email>catalin.marinas@arm.com</email>
</author>
<published>2009-07-07T09:32:59Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=e4f7c0b44a8ac8935f223195af9ea637d0c08091'/>
<id>urn:sha1:e4f7c0b44a8ac8935f223195af9ea637d0c08091</id>
<content type='text'>
The kmalloc_large() and kmalloc_large_node() functions were missed when
adding the kmemleak hooks to the slub allocator. However, they should be
traced to avoid false positives.

Signed-off-by: Catalin Marinas &lt;catalin.marinas@arm.com&gt;
Cc: Christoph Lameter &lt;cl@linux-foundation.org&gt;
Acked-by: Pekka Enberg &lt;penberg@cs.helsinki.fi&gt;
</content>
</entry>
</feed>
