Question

This question is mystifying me for years and considering this site’s name, this is the place to ask.

Why do we, programmers, still have this StackOverflow problem?

Why in every major language does the thread stack memory have to be statically allocated on thread creation?

I will speak in the context of C#/Java, because I use them most, but this is probably a broader problem.

Fixed stack size leads to huge problems:

• There is no way to write a recursive algorithm unless you are absolutely sure that the depth of recursion is tiny. Linear memory complexity of the recursive algorithm is often unacceptable.
• There is no cheap way to start new threads. You have to allocate huge block of memory for stack to account for all the possible uses of the thread.
• Even if you don’t use very deep recursion, you always have a risk of running out of stack space for the reason that the stack size is an arbitrary fixed number. Considering that the StackOverflow is usually unrecoverable, this is a big problem in my eyes.

Now, if the stack was resized dynamically, all of the problems above would be much alleviated, because stack overflow would only be possible when there is a memory overflow.

But this is not the case yet. Why? Are there some fundamental limitations of modern CPUs which would make it impossible/inefficient? If you think about the performance hit that reallocations would impose, it should be acceptable because people use structures like ArrayList all the time without suffering much.

So, the question is, am I missing something and the StackOverflow is not a problem, or am I missing something and there are a lot of languages with dynamic stack, or is there some big reason for this being impossible/hard to implement?

Edit:
Some people said that performance would be a large problem, but consider this:

• We leave the compiled code untouched. The stack access stays the same, thus the “usual case” performance stays the same.
• We handle CPU exception which happens when the code tries to access the unallocated memory and launch our “reallocation” routine. Reallocations won’t be frequent because <put your usual ArrayList argument here>. Should work on most protected-mode CPUs without loss of performance. No?

Answer 1

I am going to summarize the arguments in the answers so far because I find no answer covering this topic good enough.

Static stack investigation

Motivation

Not everyone needs it.

• Most algorithms do not use deep recursion or a lot of threads, thus not a lot of people need dynamic stacks.
• Dynamic stack would make an infinite-recursion stack overflow, which is an easy mistake to make, harder to diagnose. (memory overflow, while being as deadly as a stack overflow to the current process, is hazardous for other processess as well)
• Every recursive algorithm can be emulated with a similar iterative one.

Implementation difficulties

Dynamic stack implementation turns out to be not as straightforward as it seems.

• Stack resizing alone is not enough unless you have unlimited address space. You will sometimes need to relocate the stack as well.
• Stack relocation would require updates for all the pointers to the data structures allocated on the stack. While it is straightforward (at least in managed languages) for the data in memory, there is no easy way to do the same for data in the CPU registers of the thread.
• Some CPUs (microcontrollers in particular) implement the stack directly on hardware, separate from the main memory.

Existing implementations

There are some languages or runtime libraries that already have the dynamic stack feature or something similar to it.

• Some runtime libraries (which?) do not pre-commit the entire block of memory allocated for stack. This can alleviate the problem, expecially for 64-bit systems, but not completely eliminate it.
• Ira Baxter told us about PARLANSE, a language specifically designed for dealing with complex data structures with high degree of parallelism. It uses small heap-allocated “grains” of work instead of stack.
• fuzzy lolipop told us that “Properly written Erlang doesn’t have stackoverflows!”
• Google Go programming language is said to have a dynamic stack. (a link would be nice)

I would like to see more examples here.

I hope I didn’t forget any important pieces of information on this subject. Making this a community wiki so that anyone can add new information.