What would realloc do if there is no sequential sp

Question

realloc is used to reallocate the memory dynamically.

Suppose I have allocated 7 bytes using the malloc function and now I want to extend it to 30 bytes.

What will happen in the background if there is no sequential (continously in a single row) space of 30 bytes in the memory?

Is there any error or will memory be allocated in parts?

Answer 1

In general, it depends on the implementation. On x86(-64) Linux, I believe the standard doug lea malloc algorithm will always allocate a minimum of a standard x86 page (4096 bytes) so for the scenario you described above, it would just reset the boundaries to accomodate the extra bytes. When it comes to, say, reallocating a buffer of 7bytes to PAGE_SIZE+1 I believe it will try to allocate the next contiguous page if available.

Worth reading the following, if you're developing on Linux:

By default, Linux follows an optimistic memory allocation strategy. This means that when malloc() returns non-NULL there is no guarantee that the memory really is available. This is a really bad bug. In case it turns out that the system is out of memory, one or more processes will be killed by the infamous OOM killer. In case Linux is employed under circumstances where it would be less desirable to suddenly lose some randomly picked processes, and moreover the kernel version is sufficiently recent, one can switch off this overcommitting behavior using a command like:

# echo 2 > /proc/sys/vm/overcommit_memory

See also the kernel Documentation directory, files vm/overcommit-accounting and sysctl/vm.txt.

Answer 2

realloc works behind the scenes roughly like this:

• If there is enough free space behind the current block to fulfill the request, extend the current block and return a pointer to the beginning of the block.
• Else if there is a large enough free block elsewhere, then allocate that block, copy the data from the old block over, free the old block and return a pointer to the beginning of the new block
• Else report failure by returning NULL.

So, you can test for failure by testing for NULL, but be aware that you don't overwrite the old pointer too early:

int* p = malloc(x);
/* ... */
p = realloc(p, y); /* WRONG: Old pointer lost if realloc fails: memory leak! */
/* Correct way: */
{
  int* temp = realloc(p, y);
  if (NULL == temp)
  {
    /* Handle error; p is still valid */
  }
  else
  {
    /* p now possibly points to deallocated memory. Overwrite it with the pointer
       to the new block, to start using that */
    p = temp;
  }
}

Answer 3

FreeBSD and Mac OS X have the reallocf() function that will free the passed pointer when the requested memory cannot be allocated (see man realloc).

Answer 4

realloc will only succeed if it can return a contiguous ("sequential" in your words) block of memory. If no such block exists, it will return NULL.

Answer 5

From the man page:

realloc() returns a pointer to the newly allocated memory, which is suitably aligned for any kind of variable and may be different from ptr, or NULL if the request fails.

So in other words, to detect failure, just check whether the result was NULL.

EDIT: As noted in the comment, if the call fails, the original memory isn't freed.