When do you worry about stack size?

Question

When you are programming in a language that allows you to use automatic allocation for very large objects, when and how do you worry about stack size? Are there any rules o

Answer 1

Shouldn't you be avoiding using the stack for allocating large objects in the first place? Use the heap, no?

Answer 2

I worry about stack size on embedded systems when call stack goes very deep and each function allocates variables (on the stack). Generally, panic evolves when the system crashes unexpectedly due to variables changing on the stack (the stack overflows).

Answer 3

I never worry about it. If there is a stack overflow, I will soon know about it. Also, in C++ it is actually very hard to create very large objects on the stack. About the only way of doing it is:

struct S {
   char big[1000000];
};

but use of std::string or std::vector makes that problem go away.

Answer 4

You start to worry about stack size when

• someone on your team cunningly invents a recursive function that goes on and on and on...
• you create a thread factory and suddenly need a tenfold of the stack that you used to need (each thread needs a stack => the more threads you have, the less free space remains for a given stack size)

Answer 5

If you're writing for a tiny little embedded platform, you worry about it all the time, but you also know exactly how big it is, and probably have some useful tools available to find the high-water mark of the stack.

If you aren't, then don't worry until your program crashes :) Unless you are allocating seriously huge objects (many tens of KB), then it is never going to be a problem.

Note, however, that objects on the stack are, by definition, temporary. Constructing (and possibly destructing) large objects frequently may cause you a performance problem - so if you have a large object it probably should be persistent and heap-based for reasons other than stack size.

Answer 6

Only time really is when you are threading and have to define it yourself, when you are doing recursion or when for some reason you are allocating to the stack. Otherwise the compiler takes care of making sure you have enough stack space.

CreateThread by default only allocates 0x100000 bytes for the stack.