Thread: malloc()

Referring to - http://www.mkssoftware.com/docs/man3/malloc.3.asp

I would be obliged to see explanation for this

"Unlike many UNIX platforms, the heap that is used by malloc(), calloc(), and realloc() is not guaranteed to be one contiguous piece of memory. ok!

Thus it is invalid to assume that all memory between two pointers returned by these functions is accessible, -- didnt get it

and it is invalid to compare pointers returned by these functions to determine the total size of the heap." -- how can i compare pointers to determine size of heap?

Originally Posted by Desolation

I don't get the last either, but the second one refers to a common trick in C. If the memory is contiguous, you can do pointer arithmetic and simply increment the pointer, which will add 1 * sizeof(whatever type) to the pointer address. However, if memory is not contiguous, you cannot assume that pointer + 1 * sizeof(whatever type) will get you to the next element of your pointer.

ah, ok got the second one now, how abt third ?

Originally Posted by anon

What it says is that if you do this
[code]
If malloc didn't fail, you can be quite sure that a points to size1 of contiguous memory and you can use pointer arithmetics on this range as much as you like.

malloc does not return pointer to contiguous allocated memory!

Originally Posted by vb.bajpai

malloc does not return pointer to contiguous allocated memory!

I think you're misunderstanding. If you ask malloc() for X bytes, you get a pointer to a CONTIGUOUS region of memory of at least X bytes in length. Obviously the chunks you ask for will be allocated contiguously (otherwise how would you know which regions you could access?)

The problem is when you do something like this:

Code:

int *a = malloc(100 * sizeof(int));
int *b = malloc(100 * sizeof(int));

And then assume that ALL memory between a and b can be accessed. If a and b are directly adjacent to each other (in other words, if a + 100 * sizeof(int) == b, or vice versa), then there is no question as there is no "dead space." But if that were not the case, you still could not assume that the intervening memory is legally addressable. THAT's what they mean by "the heap is not guaranteed to be contiguous." Make sense?

This isn't even generally true on UNIX systems either. Yes, normally malloc() carves chunks out of the data segment using sbrk(), but it is not required to -- it could get the memory some other way, like creating an anonymous memory map (in fact, the GNU C library does this for very large blocks).

ok!, got the 2nd point, plz clarify on the 3rd point please