• Joseph Rushton Wakeling (22/22) Apr 04 2014 Hello all,
• bearophile (7/9) Apr 04 2014 Manually allocated memory can over-allocate, but not

Joseph Rushton Wakeling <joseph.wakeling webdrake.net> writes:

Hello all,

If we change the length of a dynamic array using the normal GC-based methods, 
e.g. by setting the array's .length property, we find that the array's capacity 
typically does not simply equal the length, but some greater value; there is 
excess allocation.

Question: is there a comparable phenomenon for memory that is manually
allocated 
using malloc?  That is, that if we specify a particular number of bytes to 
allocate, it may be rounded up to a particular larger number?

And, if so -- is there any way of guaranteeing what that larger number will be?

The reason I ask is because, suppose that I use a dynamic array as a fixed-size 
buffer, and that its minimum size must be n.  So, I can do:

     arr.length = n;
     if (arr.capacity > arr.length)
     {
         arr.length = arr.capacity;
     }

... and get the largest possible buffer that is at least size n, but does not 
allocate any more memory than setting length = n.

I'm wondering if I can do something similar with manual memory allocation.

Thanks in advance for any comments and advice!

Best wishes,

     -- Joe

"bearophile" <bearophileHUGS lycos.com> writes:

Joseph Rushton Wakeling:

 Question: is there a comparable phenomenon for memory that is 
 manually allocated using malloc?

Manually allocated memory can over-allocate, but not 
geometrically as arrays do.

Take a look at the difference between core.memory.extend and 
core.memory.realloc.

Bye,
bearophile