How much stack memory

If the stack would be allowed to grow arbitrarily large, these errors like infinite recursion would be caught very late, only after the operating systems resources are exhausted. This is prevented by setting an arbitrary limit to the stack size. The actual size is not that important, apart from it being small enough to prevent system degradation. It is just a default size. If you need more, you can get more - most often by telling the linker to allocate extra stack space.

The downside to having large stacks is that if you create many threads, they will need one stack each. If all the stacks are allocating multi-MBs, but not using it, the space will be wasted. Some people, like BJovke, believe that virtual memory is essentially free. It is true that you don't need to have physical memory backing all the virtual memory.

You do have to be able to at least give out addresses to the virtual memory. However, on a typical bit PC the size of the virtual memory is the same as the size of the physical memory - because we only have 32 bits for any address, virtual or not. Because all threads in a process share the same address space, they have to divide it between them. And after the operating system has taken its part, there is "only" GB left for an application.

And that size is the limit for both the physical and the virtual memory, because there just aren't any more addresses. For one thing, the stack is continuous, so if you allocate 12MB, you must remove 12MB when you want to go below whatever you created.

Also moving objects around becomes much harder. Here is a real world example that may make things easier to understand:. Those two examples are gross generalizations and there are some points that are blatantly wrong in the analogy but it is close enough that it hopefully will help you see the advantages in both cases.

Think of the stack in the order of near to far. Registers are close to the CPU fast , the stack is a bit further but still relatively close and the heap is far away slow access. The stack lives on the heap ofcourse, but still, since it's being used continuously, it probably never leaves the CPU cache s , making it faster than just the average heap access. This is a reason to keep the stack reasonably sized; to keep it cached as much as possible.

Allocating big stack objects possibly automatically resizing the stack as you get overflows goes against this principle. Sedgewick's "Algorithms" has a couple good examples of "removing" recursion from recursive algorithms such as QuickSort, by replacing the recursion with iteration. In reality, the algorithm is still recursive, and there is still as stack, but you allocate the sorting stack on the heap, rather than using the runtime stack.

I favor the second edition, with algorithms given in Pascal. It can be had used for eight bucks. Another way to look at it, is if you think you need a big stack, your code is inefficient.

There is a better way that uses less stack. Allocating large objects in a, say, MB stack would make it impossible on most machines to have them loaded at once into cache, which pretty much defeats the purpose of the stack.

The point of the stack is to have small objects that belong to the same scope and are, therefore, usually needed together or close to each other stored together in contiguous memory addresses, so that the program can have them all loaded into cache at the same time, minimizing cache misses and, in general, the time CPU has to wait until it gets some missing piece of data from the slower RAM.

A 50MB object stored in the stack would not fit into the cache, meaning after every cache line there would be a CPU waiting time until the next piece of data is brought from RAM, meaning one would be clogging the call stack and not getting any significant benefit in terms of speed as compared to loading from the heap.

I don't think there is any technical reason, but it would be a strange app that just created just one huge super-object on the stack. Stack objects lack flexibility that becomes more problematic with increasing size - you cannot return without destroying them and you cannot queue them to other threads.

Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. Ask Question. Asked 9 years, 6 months ago. Active 7 months ago. Viewed 34k times. Improve this question. Why would it be practical to create large objects on the heap?

Call chains typically go on the stack. This means that you cannot randomly allocate the stack as needed, but you need to at least reserve virtual addresses for that purpose. The larger the size of the reserved virtual address space, the fewer threads you can create. The stack area is typically 1 to 8Mb, and that's memory used by the compiler to store automatic variables declared in functions , and function arguments.

The heap is potentially all the remaining virtual memory space of your process, and what is used to allocate memory when using new or malloc. A typical stack is an area of computer memory with a fixed origin and a variable size. Initially the size of the stack is zero. A stack is a container of objects that are inserted and removed according to the last-in first-out LIFO principle.

A stack is a limited access data structure - elements can be added and removed from the stack only at the top. Stack empty Method in Java Stack. The method is of boolean type and returns true if the stack is empty else false. Return Value: The method returns boolean true if the stack is empty else it returns false.

A stack is a special area of computer's memory which stores temporary variables created by a function. In stack , variables are declared, stored and initialized during runtime. It is a temporary storage memory. The stack section mostly contains methods, local variable, and reference variables. What is Java Heap Size. The Java heap is the amount of memory allocated to applications running in the JVM.

Objects in heap memory can be shared between threads. The practical limit for Java heap size is typically about GB in a conventional JVM due to garbage collection pauses. Stack overflow. Usually, when a stack overflow error occurs , the program crashes and can either freeze or close the program.

Any unsaved data or work is lost. The stack overflow error is often caused by an infinite loop, or the creation of variables that are larger than the size of the call stack.

In such case, thread stack size should be reduced. In the majority of modern architectures, stack grows down. Skip to content. Stack memory will never become fragmented whereas Heap memory can become fragmented as blocks of memory are first allocated and then freed. Stack accesses local variables only while Heap allows you to access variables globally.

Stack memory is allocated in a contiguous block whereas Heap memory is allocated in any random order. Stack allocation and deallocation are done by compiler instructions whereas Heap allocation and deallocation is done by the programmer. Report a Bug. Previous Prev. Next Continue. Home Testing Expand child menu Expand. SAP Expand child menu Expand. Web Expand child menu Expand.