Comments on: C: Power of 2 Array Sizes http://thesmithfam.org/blog/2005/09/18/power-of-2-array-sizes/ Your blog is probably better than mine. Wed, 19 Nov 2008 04:59:07 +0000 http://wordpress.org/?v=2.6.3 By: Michael J M Thomson http://thesmithfam.org/blog/2005/09/18/power-of-2-array-sizes/#comment-6651 Michael J M Thomson Sat, 17 Feb 2007 19:20:41 +0000 http://thesmithfam.org/blog/?p=5#comment-6651 I'm sorry to say, but you're on the wrong track. The chief reason to request sizes from malloc() that are powers of two, is to reduce fragmentation in the way malloc() and free() etc. manage the heap. It has to do with the fact that often when you request memory areas with malloc() and then later free() them, instead of these functions getting the OS every single time to adjust how much heap is available (which would be incredibly expensive), free() will often instead make a note of the freed area in a list, the "free list", that malloc() can then exploit when fulfilling later requests. malloc() searches that list for an unused area of the heap that is at least the size requested, and if it finds one and it is larger than requested, the size of the excess area will get put back in the list. Now, with all that in mind, it should make sense that the free list is much more useful when the sizes are _evenly_divisible_ by virtue of them being powers of two. E.g. a call to free(32) followed by two calls to malloc(16) will perform better than if the former was a call to free(30), or if the latter were two calls to malloc(20). Also worth pointing out, increasing e.g. a string's capacity by multiplying by 2 each time (and starting with a power of 2 of course), always means far less calls to realloc() than if you were to increase it linearly. As for arrays, provided they're on the stack, make them the size you actually need. There's no performance gain to be had, the stack size will be increased once when the array comes into scope and decreased once when it leaves, regardless. I don't think indexing them is really an issue, as you say compilers will optimize things whereever possible, and I doubt modern processors have much more trouble with integer multiplication (generally a shift followed by zero or more adds) than with integer shift. HTH. If not, try http://en.wikipedia.org/wiki/Dynamic_memory_allocation and the links from there, or google for Sun or IBM docs on the subject (I knew of at least one but can't find it offhand). I’m sorry to say, but you’re on the wrong track. The chief reason to request sizes from malloc() that are powers of two, is to reduce fragmentation in the way malloc() and free() etc. manage the heap. It has to do with the fact that often when you request memory areas with malloc() and then later free() them, instead of these functions getting the OS every single time to adjust how much heap is available (which would be incredibly expensive), free() will often instead make a note of the freed area in a list, the “free list”, that malloc() can then exploit when fulfilling later requests. malloc() searches that list for an unused area of the heap that is at least the size requested, and if it finds one and it is larger than requested, the size of the excess area will get put back in the list. Now, with all that in mind, it should make sense that the free list is much more useful when the sizes are _evenly_divisible_ by virtue of them being powers of two. E.g. a call to free(32) followed by two calls to malloc(16) will perform better than if the former was a call to free(30), or if the latter were two calls to malloc(20).

Also worth pointing out, increasing e.g. a string’s capacity by multiplying by 2 each time (and starting with a power of 2 of course), always means far less calls to realloc() than if you were to increase it linearly.

As for arrays, provided they’re on the stack, make them the size you actually need. There’s no performance gain to be had, the stack size will be increased once when the array comes into scope and decreased once when it leaves, regardless. I don’t think indexing them is really an issue, as you say compilers will optimize things whereever possible, and I doubt modern processors have much more trouble with integer multiplication (generally a shift followed by zero or more adds) than with integer shift.

HTH. If not, try http://en.wikipedia.org/wiki/Dynamic_memory_allocation and the links from there, or google for Sun or IBM docs on the subject (I knew of at least one but can’t find it offhand).

]]>