Freeing portions of dynamically allocated blocks?

Question

I was curious whether there exists a dynamic memory allocation system that allows the programmer to free part of an allocated block.

For example:

char* a = malloc (40);
//b points to the split second half of the block, or to NULL if it's beyond the end
//a points to a area of 10 bytes
b = partial_free (a+10, /*size*/ 10) 

Thoughts on why this is wise/unwise/difficult? Ways to do this?

Seems to me like it could be useful.

Thanks!

=====edit===== after some research, it seems that the bootmem allocator for the linux kernel allows something similar to this operation with the bootmem_free call. So, I'm curious -- why is it that the bootmem allocator allows this, but ANSI C does not?

Answer 1

No there is no such function which allows parital freeing of memory.
You could however use realloc() to resize memory.

From the c standard:

7.22.3.5 The realloc function

#include <stdlib.h>
void *realloc(void *ptr, size_t size);

The realloc function deallocates the old object pointed to by ptr and returns a pointer to a new object that has the size specified by size. The contents of the new object shall be the same as that of the old object prior to deallocation, up to the lesser of the new and old sizes. Any bytes in the new object beyond the size of the old object have indeterminate values.

Answer 2

There is no ready-made function for this, but doing this isn't impossible. Firstly, there is realloc() . realloc takes a pointer to a block of memory and resizes the allocation to the size specified.

Now, if you have allocated some memory:

char * tmp = malloc(2048); 

and you intend to deallocate the first, 1 K of memory, you may do:

tmp = realloc(foo, 2048-1024);

However, the problem in this case is that you cannot be certain that tmp will remain unchanged. Since, the function might just deallocate the entire 2K memory and move it elsewhere.

Now I'm not sure about the exact implementation of realloc , but from what I understand, the code:

myptr = malloc( x - y );

actually malloc sa new memory buffer of size xy , then it copies the bytes that fit using memcpy and finally free s the original allocated memory.

This may create some potential problems. For example, the new reallocated memory may be located at a different address, so any past pointers you may have may become invalidated. Resulting in undefined runtime errors, segmentation faults and general debugging hell. So I would try to avoid resorting to this.

Answer 3

Firstly, I cannot think of any situation where you would be likely to need such a thing (when there exists realloc to increase/decrease the memory as mentioned in the answers).

I would like to add another thing. In whatever implementations I have seen of the malloc subsystem (which I admit is not a lot), malloc and free are implemented to be dependent on something called as the prefix byte(s). So whatever address is returned to you by malloc, internally the malloc subsystem will allocate some additional byte(s) of memory prior to the address returned to you, to store sanity check information which includes number of allocated bytes and possible what allocation policy you use (if your OS supports multiple mem allocation policies) etc. When you say something like free (x bytes), the malloc subsystem goes back to peek back into the prefix byte to sanity check and only if it finds the prefix in place does the free successfully happen. Therefore, it will not allow you to free some number of blocks starting in between.