CODEWITHSUNDEEP
cmalloc
Fei Xue
Fei Xue

Reputation: 2045

What is the difference between the two allocation methods?

I want to test how much the OS does allocate when I request 24M memory.

    for (i = 0; i < 1024*1024; i++)
            ptr = (char *)malloc(24);

When I write like this I get RES is 32M from the top command. 

    ptr = (char *)malloc(24*1024*1024);

But when I do a little change the RES is 244. What is the difference between them? Why is the result 244?

Upvotes: 2

Views: 218

Answers (3)

user988106
user988106

Reputation:

In addition to what has been said: It could be that some compilers notice how you allocate multiple 24 Byte Blocks in a loop, assigning their addresses to the same pointer and keeping only the last block you allocated, effectively rendering every other malloc from before useless. So it may optimize your whole loop into something like this:

ptr = (char *)malloc(24);
i = 1024*1024;

Upvotes: 0

cnicutar
cnicutar

Reputation: 182619

The second allocation barely touches the memory. The allocator tells you "okay, you can have it" but if you don't actually touch the memory, the OS never actually gives it to you, hoping you'll never use it. Bit like a Ponzi scheme. On the other hand, the other method writes something (a few bytes at most) to many pages, so the OS is forced to actually give you the memory.

Try this to verify, you should get about 24m usage:

memset(ptr, 1, 1024 * 1024 * 24);

In short, top doesn't tell you how much you allocated, i.e. what you asked from malloc. It tells you what the OS allocated to your process.

Upvotes: 6

Blagovest Buyukliev
Blagovest Buyukliev

Reputation: 43508

The allocator has its own data structures about the bookkeeping that require memory as well. When you allocate in small chunks (the first case), the allocator has to keep a lot of additional data about where each chunk is allocated and how long it is. Moreover, you may get gaps of unused memory in between the chunks because malloc has a requirement to return a sufficiently aligned block, most usually on an 8-byte boundary.

In the second case, the allocator gives you just one contiguous block and does bookkeeping only for that block.

Always be careful with a large number of small allocations, as the bookkeeping memory overhead may even outweigh the amount of the data itself.

Upvotes: 7

Related Questions