哪个分配更快？ malloc vs局部变量

Question

Which is preferable way to allocate memory for a function that is frequently allocating and freeing memory ? Assume this function is getting called around 500 to 1000 times a second on a 1GHz Processor.

(Please ignore static and global variables/allocation. I am interested only this specific case:)

void Test()
{
    ptr=malloc(512)   // 512 bytes
    ...
    free(ptr) 
}

OR

void Test()
{
     struct MyStruct localvar; // 512 byte sized structure
     ... 
}

Answer 1

stack allocation of local variables is faster than heap allocation with malloc . However, the total stack space is limited (eg to several megabytes). So you should limit yourself to "small" data on the local stack. (and 512 bytes is small by today's standard, but 256Kb would be too large for local stack allocation).

If your function is very deeply recursive, then perhaps even 512 bytes could be too big, because you'll need that for each recursive call frame.

But calling malloc a few thousands time per second should be painless (IMHO a typical small-sized malloc takes a few dozens of microseconds).

For your curiosity, and outside of the C world, you might be interested by old A.Appel's paper garbage collection can be faster than stack allocation (but perhaps cache performance considerations could weaken this claim today).

Answer 2

Local variables are allocated essentially "for free", so there is no contest here if we are only interested in performance.

However:

• the choice between a local and a heap-allocated variable is not normally something that you are free to decide without constraint; usually there are factors that mandate the choice, so your question is a bit suspect because it seems to disregard this issue
• while allocating on the stack is "free" performance-wise, space on the stack might be limited (although of course 512 bytes is nothing)

Answer 3

• Which is preferable way to allocate memory....
• Which allocation is faster ?

Do you want the faster way,or the preferable way?

Anyway, in the case you mentioned, I think the second option:

struct MyStruct localvar;

is more efficient, since the memory allocation is done by the Stack . Which is a lot more efficient that using dynamic memory allocation functions like malloc .

Optimizing

Also, if you are doing this for performance & optimizing...

On my PC, using malloc to allocate strings instead of declaring a char array from the stack gives me a lag of ~ 73 nanoseconds per string.

if you copied 50 strings in your program: 4757142 / 50 = 95142 (and a bit) runs of your program

If I run your program 50 times a day: 95142 / 50 = 1902 (and a bit) days

1902 days = 5 1/5 years

So if you run your program every day for 5 years and 2 months, you'll save the time to blink your eye an extra time. Wow, how rewarding...

Answer 4

Turn on your disassembler when you enter your function, and step through the 2 cases.

The local variable (stack based) will require 0 extra cycles -- you won't even see where the allocation comes, because the function will allocate all the local variables in 1 cycle by just moving the stack pointer, and free all the local variables in 1 cycle by restoring the stack pointer. It doesn't matter if you have 1 or 1000 local variables, the "allocation" takes the same amount of time.

The malloc variable ... well, you will quickly get bored click-stepping through the thousands of instructions that are executed to get memory from the system heap. On top of that, you might notice that the number of cycles varies from call to call, depending on how many things you have already allocated from the heap, as malloc requires a "search" through the heap structure every time you ask for memory.

My rule of thumb : always use the stack if possible, instead of malloc/free or new/delete . In addition to faster performance, you get the added benefit of not having to worry about memory or resource leaks. In C this just means forgetting to call free() , but in C++ exceptions can ruin your day if something throws an exception before you call delete . If you use stack variables, this is all handled automatically! However, only use the stack if you are talking about "small" pieces of memory (bytes and KB) and not huge objects (not MB or GB!). If you are talking about huge objects anyways, you are not talking about performance any more and you will probably not be calling free/delete in the same function call anyways.

Answer 5

Stack allocation is faster than malloc + free .

Stack allocations are typically measured in instructions, while malloc + free may require multiple locks (as one example of why it takes long in comparison).

Answer 6

The local variable case will be much faster: allocating a variable on the stack takes no extra time, it just changes the amount the stack pointer is moved. Whereas malloc will have to do some bookkeeping.

Answer 7

Another advantage by using the stack is that it does not fragment the memory space, which the malloc has a tendency to do. Of course this is just an issue for long-running processes.