On Mon, 2008-07-28 at 11:49 -0500, Matt Mackall wrote:

On Mon, 2008-07-28 at 13:06 +0300, Pekka Enberg wrote:

quoted

We're trying to get rid of kfree() so I'd __kfree_reserve() could to
mm/sl?b.c. Matt, thoughts?

I think you mean ksize there. My big issue is that we need to make it
clear that ksize pairs -only- with kmalloc and that
ksize(kmem_cache_alloc(...)) is a categorical error. Preferably, we do
this by giving it a distinct name, like kmalloc_size(). We can stick an
underbar in front of it to suggest you ought not be using it too.

Right, both make sense, so _kmalloc_size() has my vote.

quoted

quoted

+	/*
+	 * ksize gives the full allocated size vs the requested size we

used to

quoted

+	 * charge; however since we round up to the nearest power of two,

this

quoted

+	 * should all work nicely.
+	 */

SLOB doesn't do this, of course. But does that matter? I think you want
to charge the actual allocation size to the reserve in all cases, no?
That probably means calling ksize() on both alloc and free.

Like said, I still need to do all the SLOB reservation stuff. That
includes coming up with upper bound fragmentation loss.

For SL[UA]B I use roundup_power_of_two for kmalloc sizes. Thus with the
above ksize(), if we did p=kmalloc(x), then we'd account
roundup_power_of_two(x), and that should be equal to
roundup_power_of_two(ksize(p)), as ksize will always be smaller or equal
to the roundup.

I'm guessing the power of two upper bound is good for SLOB too -
although I haven't tried proving it wrong or tighetening it.

Only the kmem_cache_* reservation stuff would need some extra attention
with SLOB.