Which is faster Stack allocation or Heap allocation

Question

This question may sound fairly elementary  but this is a debate I had with another developer I work with   I was taking care to stack allocate things where I could  instead of heap allocating them  He was talking to me and watching over my shoulder and commented that it wasn t necessary because they are the same performance wise   I was always under the impression that growing the stack was constant time  and heap allocation s performance depended on the current complexity of the heap for both allocation  finding a hole of the proper size  and de-allocating  collapsing holes to reduce fragmentation  as many standard library implementations take time to do this during deletes if I am not mistaken    This strikes me as something that would probably be very compiler dependent  For this project in particular I am using a Metrowerks compiler for the PPC architecture  Insight on this combination would be most helpful  but in general  for GCC  and MSVC    what is the case  Is heap allocation not as high performing as stack allocation  Is there no difference  Or are the differences so minute it becomes pointless micro-optimization

User · Answer

Aside from the orders-of-magnitude performance advantage over heap allocation  stack allocation is preferable for long running server applications   Even the best managed heaps eventually get so fragmented that application performance degrades

User · Answer

I think the lifetime is crucial  and whether the thing being allocated has to be constructed in a complex way   For example  in transaction-driven modeling  you usually have to fill in and pass in a transaction structure with a bunch of fields to operation functions   Look at the OSCI SystemC TLM-2 0 standard for an example   Allocating these on the stack close to the call to the operation tends to cause enormous overhead  as the construction is expensive   The good way there is to allocate on the heap and reuse the transaction objects either by pooling or a simple policy like  this module only needs one transaction object ever     This is many times faster than allocating the object on each operation call    The reason is simply that the object has an expensive construction and a fairly long useful lifetime    I would say  try both and see what works best in your case  because it can really depend on the behavior of your code

User · Answer

Stack allocation is a couple instructions whereas the fastest rtos heap allocator known to me  TLSF  uses on average on the order of 150 instructions  Also stack allocations don t require a lock because they use thread local storage which is another huge performance win  So stack allocations can be 2-3 orders of magnitude faster depending on how heavily multithreaded your environment is   In general heap allocation is your last resort if you care about performance  A viable in-between option can be a fixed pool allocator which is also only a couple instructions and has very little per-allocation overhead so it s great for small fixed size objects  On the downside it only works with fixed size objects  is not inherently thread safe and has block fragmentation problems

User · Answer

Never do premature assumption as other application code and usage can impact your function  So looking at function is isolation is of no use   If you are serious with application then VTune it or use any similar profiling tool and look at hotspots   Ketan

User · Answer

Stack allocation will almost always be as fast or faster than heap allocation  although it is certainly possible for a heap allocator to simply use a stack based allocation technique   However  there are larger issues when dealing with the overall performance of stack vs  heap based allocation  or in slightly better terms  local vs  external allocation   Usually  heap  external  allocation is slow because it is dealing with many different kinds of allocations and allocation patterns  Reducing the scope of the allocator you are using  making it local to the algorithm code  will tend to increase performance without any major changes  Adding better structure to your allocation patterns  for example  forcing a LIFO ordering on allocation and deallocation pairs can also improve your allocator s performance by using the allocator in a simpler and more structured way  Or  you can use or write an allocator tuned for your particular allocation pattern  most programs allocate a few discrete sizes frequently  so a heap that is based on a lookaside buffer of a few fixed  preferably known  sizes will perform extremely well  Windows uses its low-fragmentation-heap for this very reason   On the other hand  stack-based allocation on a 32-bit memory range is also fraught with peril if you have too many threads  Stacks need a contiguous memory range  so the more threads you have  the more virtual address space you will need for them to run without a stack overflow  This won t be a problem  for now  with 64-bit  but it can certainly wreak havoc in long running programs with lots of threads  Running out of virtual address space due to fragmentation is always a pain to deal with

User · Answer

Never do premature assumption as other application code and usage can impact your function  So looking at function is isolation is of no use   If you are serious with application then VTune it or use any similar profiling tool and look at hotspots   Ketan

User · Answer

class Foo   public      Foo int a             int func         int a1  a2      std  cin  gt  gt  a1      std  cin  gt  gt  a2       Foo f1 a1         asm push a1        asm lea ecx   this         asm call Foo  Foo int        Foo  f2   new Foo a2         asm push sizeof Foo         asm call operator new   there s a lot instruction here depends on system        asm push a2        asm call Foo  Foo int        delete f2      It would be like this in asm  When you re in func  the f1 and pointer f2 has been allocated on stack  automated storage   And by the way  Foo f1 a1  has no instruction effects on stack pointer  esp  It has been allocated  if func wants get the member f1  it s instruction is something like this  lea ecx  ebp f1   call Foo  SomeFunc    Another thing the stack allocate may make someone think the memory is something like FIFO  the FIFO just happened when you go into some function  if you are in the function and allocate something like int i   0  there no push happened

User · Answer

Probably the biggest problem of heap allocation versus stack allocation  is that heap allocation in the general case is an unbounded operation  and thus you can t use it where timing is an issue   For other applications where timing isn t an issue  it may not matter as much  but if you heap allocate a lot  this will affect the execution speed  Always try to use the stack for short lived and often allocated memory  for instance in loops   and as long as possible - do heap allocation during application startup

User · Answer

As others have said  stack allocation is generally much faster   However  if your objects are expensive to copy  allocating on the stack may lead to an huge performance hit later when you use the objects if you aren t careful   For example  if you allocate something on the stack  and then put it into a container  it would have been better to allocate on the heap and store the pointer in the container  e g  with a std  shared ptr lt     The same thing is true if you are passing or returning objects by value  and other similar scenarios   The point is that although stack allocation is usually better than heap allocation in many cases  sometimes if you go out of your way to stack allocate when it doesn t best fit the model of computation  it can cause more problems than it solves

User · Answer

You can write a special heap allocator for specific sizes of objects that is very performant  However  the general heap allocator is not particularly performant   Also I agree with Torbj  rn Gyllebring about the expected lifetime of objects  Good point

User · Answer

A stack has a limited capacity  while a heap is not  The typical stack for a process or thread is around 8K  You cannot change the size once it s allocated   A stack variable follows the scoping rules  while a heap one doesn t  If your instruction pointer goes beyond a function  all the new variables associated with the function go away   Most important of all  you can t predict the overall function call chain in advance  So a mere 200 bytes allocation on your part may raise a stack overflow  This is especially important if you re writing a library  not an application

User · Answer

An interesting thing I learned about Stack vs  Heap Allocation on the Xbox 360 Xenon processor  which may also apply to other multicore systems  is that allocating on the Heap causes a Critical Section to be entered to halt all other cores so that the alloc doesn t conflict   Thus  in a tight loop  Stack Allocation was the way to go for fixed sized arrays as it prevented stalls   This may be another speedup to consider if you re coding for multicore multiproc  in that your stack allocation will only be viewable by the core running your scoped function  and that will not affect any other cores CPUs

User · Answer

I don t think stack allocation and heap allocation are generally interchangable  I also hope that the performance of both of them is sufficient for general use   I d strongly recommend for small items  whichever one is more suitable to the scope of the allocation  For large items  the heap is probably necessary   On 32-bit operating systems that have multiple threads  stack is often rather limited  albeit typically to at least a few mb   because the address space needs to be carved up and sooner or later one thread stack will run into another  On single threaded systems  Linux glibc single threaded anyway  the limitation is much less because the stack can just grow and grow   On 64-bit operating systems there is enough address space to make thread stacks quite large

User · Answer

In general  stack allocation is faster than heap allocation as mentioned by almost every answer above   A stack push or pop is O 1   whereas allocating or freeing from a heap could require a walk of previous allocations   However you shouldn t usually be allocating in tight  performance-intensive loops  so the choice will usually come down to other factors   It might be good to make this distinction  you can use a  stack allocator  on the heap   Strictly speaking  I take stack allocation to mean the actual method of allocation rather than the location of the allocation   If you re allocating a lot of stuff on the actual program stack  that could be bad for a variety of reasons   On the other hand  using a stack method to allocate on the heap when possible is the best choice you can make for an allocation method   Since you mentioned Metrowerks and PPC  I m guessing you mean Wii   In this case memory is at a premium  and using a stack allocation method wherever possible guarantees that you don t waste memory on fragments   Of course  doing this requires a lot more care than  normal  heap allocation methods   It s wise to evaluate the tradeoffs for each situation

User · Answer

Concerns Specific to the C   Language  First of all  there is no so-called  stack  or  heap  allocation mandated by C    If you are talking about automatic objects in block scopes  they are even not  allocated    BTW  automatic storage duration in C is definitely NOT the same to  allocated   the latter is  dynamic  in the C   parlance   The dynamically allocated memory is on the free store  not necessarily on  the heap   though the latter is often the  default  implementation   Although as per the abstract machine semantic rules  automatic objects still occupy memory  a conforming C   implementation is allowed to ignore this fact when it can prove this does not matter  when it does not change the observable behavior of the program   This permission is granted by the as-if rule in ISO C    which is also the general clause enabling the usual optimizations  and there is also an almost same rule in ISO C   Besides the as-if rule  ISO C   also has copy elision rules to allow omission of specific creations of objects  The constructor and destructor calls involved are thereby omitted  As a result  the automatic objects  if any  in these constructors and destructors are also eliminated  compared to naive abstract semantics implied by the source code   On the other hand  free store allocation is definitely  allocation  by design  Under ISO C   rules  such an allocation can be achieved by a call of an allocation function  However  since ISO C  14  there is a new  non-as-if  rule to allow merging global allocation function  i e    operator new  calls in specific cases  So parts of dynamic allocation operations can also be no-op like the case of automatic objects   Allocation functions allocate resources of memory  Objects can be further allocated based on allocation using allocators  For automatic objects  they are directly presented - although the underlying memory can be accessed and be used to provide memory to other objects  by placement new   but this does not make great sense as the free store  because there is no way to move the resources elsewhere   All other concerns are out of the scope of C    Nevertheless  they can be still significant   About Implementations of C    C   does not expose reified activation records or some sorts of first-class continuations  e g  by the famous call cc   there is no way to directly manipulate the activation record frames - where the implementation need to place the automatic objects to  Once there is no  non-portable  interoperations with the underlying implementation   native  non-portable code  such as inline assembly code   an omission of the underlying allocation of the frames can be quite trivial  For example  when the called function is inlined  the frames can be effectively merged into others  so there is no way to show what is the  allocation    However  once interops are respected  things are getting complex  A typical implementation of C   will expose the ability of interop on ISA  instruction-set architecture  with some calling conventions as the binary boundary shared with the native  ISA-level machine  code  This would be explicitly costly  notably  when maintaining the stack pointer  which is often directly held by an ISA-level register  with probably specific machine instructions to access   The stack pointer indicates the boundary of the top frame of the  currently active  function call  When a function call is entered  a new frame is needed and the stack pointer is added or subtracted  depending on the convention of ISA  by a value not less than the required frame size  The frame is then said allocated when the stack pointer after the operations  Parameters of functions may be passed onto the stack frame as well  depending on the calling convention used for the call  The frame can hold the memory of automatic objects  probably including the parameters  specified by the C   source code  In the sense of such implementations  these objects are  allocated   When the control exits the function call  the frame is no longer needed  it is usually released by restoring the stack pointer back to the state before the call  saved previously according to the calling convention   This can be viewed as  deallocation   These operations make the activation record effectively a LIFO data structure  so it is often called  the  call  stack   The stack pointer effectively indicates the top position of the stack   Because most C   implementations  particularly the ones targeting ISA-level native code and using the assembly language as its immediate output  use similar strategies like this  such a confusing  allocation  scheme is popular  Such allocations  as well as deallocations  do spend machine cycles  and it can be expensive when the  non-optimized  calls occur frequently  even though modern CPU microarchitectures can have complex optimizations implemented by hardware for the common code pattern  like using a stack engine in implementing  PUSH POP instructions    But anyway  in general  it is true that the cost of stack frame allocation is significantly less than a call to an allocation function operating the free store  unless it is totally optimized away   which itself can have hundreds of  if not millions of  -  operations to maintain the stack pointer and other states  Allocation functions are typically based on API provided by the hosted environment  e g  runtime provided by the OS   Different to the purpose of holding automatic objects for functions calls  such allocations are general-purposed  so they will not have frame structure like a stack  Traditionally  they allocate space from the pool storage called heap  or several heaps   Different from the  stack   the concept  heap  here does not indicate the data structure being used  it is derived from early language implementations decades ago   BTW  the call stack is usually allocated with fixed or user-specified size from the heap by the environment in program or thread startup   The nature of use cases makes allocations and deallocations from a heap far more complicated  than push or pop of stack frames   and hardly possible to be directly optimized by hardware   Effects on Memory Access  The usual stack allocation always puts the new frame on the top  so it has a quite good locality  This is friendly to the cache  OTOH  memory allocated randomly in the free store has no such property  Since ISO C  17  there are pool resource templates provided by  lt memory gt   The direct purpose of such an interface is to allow the results of consecutive allocations being close together in memory  This acknowledges the fact that this strategy is generally good for performance with contemporary implementations  e g  being friendly to cache in modern architectures  This is about the performance of access rather than allocation  though   Concurrency  Expectation of concurrent access to memory can have different effects between the stack and heaps  A call stack is usually exclusively owned by one thread of execution in a C   implementation  OTOH  heaps are often shared among the threads in a process  For such heaps  the allocation and deallocation functions have to protect the shared internal administrative data structure from the data race  As a result  heap allocations and deallocations may have additional overhead due to internal synchronization operations   Space Efficiency  Due to the nature of the use cases and internal data structures  heaps may suffer from internal memory fragmentation  while the stack does not  This does not have direct impacts on the performance of memory allocation  but in a system with virtual memory  low space efficiency may degenerate overall performance of memory access  This is particularly awful when HDD is used as a swap of physical memory  It can cause quite long latency - sometimes billions of cycles   Limitations of Stack Allocations  Although stack allocations are often superior in performance than heap allocations in reality  it certainly does not mean stack allocations can always replace heap allocations   First  there is no way to allocate space on the stack with a size specified at runtime in a portable way with ISO C    There are extensions provided by implementations like alloca and G   s VLA  variable-length array   but there are reasons to avoid them   IIRC  Linux source removes the use of VLA recently    Also note ISO C99 does have mandated VLA  but ISO C11 turns the support optional    Second  there is no reliable and portable way to detect stack space exhaustion  This is often called stack overflow  hmm  the etymology of this site   but probably more accurately  stack overrun  In reality  this often causes invalid memory access  and the state of the program is then corrupted      or maybe worse  a security hole   In fact  ISO C   has no concept of  the stack  and makes it undefined behavior when the resource is exhausted  Be cautious about how much room should be left for automatic objects   If the stack space runs out  there are too many objects allocated in the stack  which can be caused by too many active calls of functions or improper use of automatic objects  Such cases may suggest the existence of bugs  e g  a recursive function call without correct exit conditions   Nevertheless  deep recursive calls are sometimes desired  In implementations of languages requiring support of unbound active calls  where the call depth only limited by total memory   it is impossible to use the  contemporary  native call stack directly as the target language activation record like typical C   implementations  To work around the problem  alternative ways of the construction of activation records are needed  For example  SML NJ explicitly allocates frames on the heap and uses cactus stacks  The complicated allocation of such activation record frames is usually not as fast as the call stack frames  However  if such languages are implemented further with the guarantee of proper tail recursion  the direct stack allocation in the object language  that is  the  object  in the language does not stored as references  but native primitive values which can be one-to-one mapped to unshared C   objects  is even more complicated with more performance penalty in general  When using C   to implement such languages  it is difficult to estimate the performance impacts

User · Answer

I d like to say actually code generate by GCC  I remember VS also  doesn t have overhead to do stack allocation   Say for following function     int f int i            if  i  gt  0                       int array 1000                    Following is the code generate       Z1fi    Leh func begin1        pushq    rbp   Ltmp0        movq     rsp   rbp   Ltmp1        subq       3880     rsp  lt --- here we have the array allocated  even the if doesn t excited    Ltmp2        movl     edi  -4  rbp        movl    -8  rbp    eax       addq     3880   rsp       popq     rbp       ret    Leh func end1    So whatevery how much local variable you have  even inside if or switch   just the 3880 will change to another value  Unless you didn t have local variable  this instruction just need to execute  So allocate local variable doesn t have overhead

User · Answer

Stack is much faster   It literally only uses a single instruction on most architectures  in most cases  e g  on x86   sub esp  0x10    That moves the stack pointer down by 0x10 bytes and thereby  allocates  those bytes for use by a variable    Of course  the stack s size is very  very finite  as you will quickly find out if you overuse stack allocation or try to do recursion  -   Also  there s little reason to optimize the performance of code that doesn t verifiably need it  such as demonstrated by profiling    Premature optimization  often causes more problems than it s worth   My rule of thumb  if I know I m going to need some data at compile-time  and it s under a few hundred bytes in size  I stack-allocate it   Otherwise I heap-allocate it

User · Answer

Stack allocation is much faster since all it really does is move the stack pointer   Using memory pools  you can get comparable performance out of heap allocation  but that comes with a slight added complexity and its own headaches    Also  stack vs  heap is not only a performance consideration  it also tells you a lot about the expected lifetime of objects

User · Answer

It s not jsut stack allocation that s faster  You also win a lot on using stack variables  They have better locality of reference  And finally  deallocation is a lot cheaper too

User · Answer

Remark that the considerations are typically not about speed and performance when choosing stack versus heap allocation  The stack acts like a stack  which means it is well suited for pushing blocks and popping them again  last in  first out  Execution of procedures is also stack-like  last procedure entered is first to be exited  In most programming languages  all the variables needed in a procedure will only be visible during the procedure s execution  thus they are pushed upon entering a procedure and popped off the stack upon exit or return   Now for an example where the stack cannot be used   Proc P     pointer x    Proc S         pointer y      y   allocate some data        x   y          If you allocate some memory in procedure S and put it on the stack and then exit S  the allocated data will be popped off the stack  But the variable x in P also pointed to that data  so x is now pointing to some place underneath the stack pointer  assume stack grows downwards  with an unknown content  The content might still be there if the stack pointer is just moved up without clearing the data beneath it  but if you start allocating new data on the stack  the pointer x might actually point to that new data instead

User · Answer

It has been mentioned before that stack allocation is simply moving the stack pointer  that is  a single instruction on most architectures  Compare that to what generally happens in the case of heap allocation   The operating system maintains portions of free memory as a linked list with the payload data consisting of the pointer to the starting address of the free portion and the size of the free portion  To allocate X bytes of memory  the link list is traversed and each note is visited in sequence  checking to see if its size is at least X  When a portion with size P    X is found  P is split into two parts with sizes X and P-X  The linked list is updated and the pointer to the first part is returned   As you can see  heap allocation depends on may factors like how much memory you are requesting  how fragmented the memory is and so on

User · Answer

There s a general point to be made about such optimizations   The optimization you get is proportional to the amount of time the program counter is actually in that code   If you sample the program counter  you will find out where it spends its time  and that is usually in a tiny part of the code  and often in library routines you have no control over   Only if you find it spending much time in the heap-allocation of your objects will it be noticeably faster to stack-allocate them

User · Answer

There s a general point to be made about such optimizations   The optimization you get is proportional to the amount of time the program counter is actually in that code   If you sample the program counter  you will find out where it spends its time  and that is usually in a tiny part of the code  and often in library routines you have no control over   Only if you find it spending much time in the heap-allocation of your objects will it be noticeably faster to stack-allocate them

User · Answer

Honestly  it s trivial to write a program to compare the performance    include  lt ctime gt   include  lt iostream gt   namespace       class empty         even empty classes take up 1 byte of space  minimum    int main         std  clock t start   std  clock        for  int i   0  i  lt  100000    i          empty e      std  clock t duration   std  clock   - start      std  cout  lt  lt   stack allocation took    lt  lt  duration  lt  lt    clock ticks n       start   std  clock        for  int i   0  i  lt  100000    i            empty  e   new empty          delete e             duration   std  clock   - start      std  cout  lt  lt   heap allocation took    lt  lt  duration  lt  lt    clock ticks n       It s said that a foolish consistency is the hobgoblin of little minds   Apparently optimizing compilers are the hobgoblins of many programmers  minds   This discussion used to be at the bottom of the answer  but people apparently can t be bothered to read that far  so I m moving it up here to avoid getting questions that I ve already answered   An optimizing compiler may notice that this code does nothing  and may optimize it all away  It is the optimizer s job to do stuff like that  and fighting the optimizer is a fool s errand   I would recommend compiling this code with optimization turned off because there is no good way to fool every optimizer currently in use or that will be in use in the future   Anybody who turns the optimizer on and then complains about fighting it should be subject to public ridicule   If I cared about nanosecond precision I wouldn t use std  clock    If I wanted to publish the results as a doctoral thesis I would make a bigger deal about this  and I would probably compare GCC  Tendra Ten15  LLVM  Watcom  Borland  Visual C    Digital Mars  ICC and other compilers   As it is  heap allocation takes hundreds of times longer than stack allocation  and I don t see anything useful about investigating the question any further   The optimizer has a mission to get rid of the code I m testing   I don t see any reason to tell the optimizer to run and then try to fool the optimizer into not actually optimizing   But if I saw value in doing that  I would do one or more of the following    Add a data member to empty  and access that data member in the loop  but if I only ever read from the data member the optimizer can do constant folding and remove the loop  if I only ever write to the data member  the optimizer may skip all but the very last iteration of the loop   Additionally  the question wasn t  stack allocation and data access vs  heap allocation and data access   Declare e volatile  but volatile is often compiled incorrectly  PDF   Take the address of e inside the loop  and maybe assign it to a variable that is declared extern and defined in another file    But even in this case  the compiler may notice that -- on the stack at least -- e will always be allocated at the same memory address  and then do constant folding like in  1  above   I get all iterations of the loop  but the object is never actually allocated    Beyond the obvious  this test is flawed in that it measures both allocation and deallocation  and the original question didn t ask about deallocation   Of course variables allocated on the stack are automatically deallocated at the end of their scope  so not calling delete would  1  skew the numbers  stack deallocation is included in the numbers about stack allocation  so it s only fair to measure heap deallocation  and  2  cause a pretty bad memory leak  unless we keep a reference to the new pointer and call delete after we ve got our time measurement   On my machine  using g   3 4 4 on Windows  I get  0 clock ticks  for both stack and heap allocation for anything less than 100000 allocations  and even then I get  0 clock ticks  for stack allocation and  15 clock ticks  for heap allocation   When I measure 10 000 000 allocations  stack allocation takes 31 clock ticks and heap allocation takes 1562 clock ticks     Yes  an optimizing compiler may elide creating the empty objects   If I understand correctly  it may even elide the whole first loop   When I bumped up the iterations to 10 000 000 stack allocation took 31 clock ticks and heap allocation took 1562 clock ticks   I think it s safe to say that without telling g   to optimize the executable  g   did not elide the constructors     In the years since I wrote this  the preference on Stack Overflow has been to post performance from optimized builds   In general  I think this is correct   However  I still think it s silly to ask the compiler to optimize code when you in fact do not want that code optimized   It strikes me as being very similar to paying extra for valet parking  but refusing to hand over the keys   In this particular case  I don t want the optimizer running   Using a slightly modified version of the benchmark  to address the valid point that the original program didn t allocate something on the stack each time through the loop  and compiling without optimizations but linking to release libraries  to address the valid point that we don t want to include any slowdown caused by linking to debug libraries     include  lt cstdio gt   include  lt chrono gt   namespace       void on stack                 int i             void on heap                 int  i   new int          delete i           int main         auto begin   std  chrono  system clock  now        for  int i   0  i  lt  1000000000    i          on stack        auto end   std  chrono  system clock  now         std  printf  on stack took  f seconds n   std  chrono  duration lt double gt  end - begin  count          begin   std  chrono  system clock  now        for  int i   0  i  lt  1000000000    i          on heap        end   std  chrono  system clock  now         std  printf  on heap took  f seconds n   std  chrono  duration lt double gt  end - begin  count         return 0      displays   on stack took 2 070003 seconds on heap took 57 980081 seconds   on my system when compiled with the command line cl foo cc  Od  MT  EHsc   You may not agree with my approach to getting a non-optimized build   That s fine   feel free modify the benchmark as much as you want   When I turn on optimization  I get   on stack took 0 000000 seconds on heap took 51 608723 seconds   Not because stack allocation is actually instantaneous but because any half-decent compiler can notice that on stack doesn t do anything useful and can be optimized away   GCC on my Linux laptop also notices that on heap doesn t do anything useful  and optimizes it away as well   on stack took 0 000003 seconds on heap took 0 000002 seconds

User · Answer

Usually stack allocation just consists of subtracting from the stack pointer register   This is tons faster than searching a heap   Sometimes stack allocation requires adding a page s  of virtual memory   Adding a new page of zeroed memory doesn t require reading a page from disk  so usually this is still going to be tons faster than searching a heap  especially if part of the heap was paged out too    In a rare situation  and you could construct such an example  enough space just happens to be available in part of the heap which is already in RAM  but allocating a new page for the stack has to wait for some other page to get written out to disk   In that rare situation  the heap is faster

[c++] Which is faster: Stack allocation or Heap allocation

Examples related to c++

Examples related to performance

Examples related to memory

Examples related to stack

Examples related to heap