Are there min / max return and/or data stack sizes?

[SirWumpus]

Forth Draft 19-1 section 12.3.3 Floating-point stack states that the float stack size must hold at least six (6) items. I'm not able to find any similar statements concerning the return and data stacks.

From my readings so far, historically in a flat memory model, the return and data stacks grew downwards towards the dictionary. I assume the return stack sat above the data stack and had some maximum size before hitting the data stack. The data stack grew until it ran into the dictionary, essentially allowing for very large, though variable, data stack.

Is there a preferred minimum and/or maximum for the return and/or data stack sizes? Or is it something left up to each implementation based on the target operating environment(s)?

[ruv]

I'm not able to find any similar statements concerning the return and data stacks.

Yes, the standard does not declare a minimal size for the data stack or return stack.

It's an implementation defined option. 4.1.3 Other system documentation says:

• A system shall provide the following information:

• • return stack space available, in cells;

• • stack space available, in cells;

And an ambiguous condition exists in a case of "insufficient data-stack space or return-stack space (stack overflow)" (4.1.2 Ambiguous conditions).

"Implementation defined" is a formal term:

• implementation defined: Denotes system behaviors or features that must be provided and documented by a system but whose further details are not prescribed by this standard.

---

Is there a preferred minimum and/or maximum for the return and/or data stack sizes? Or is it something left up to each implementation based on the target operating environment(s)?

I think, it's much depends on the target environment.

A good choice is to provide a way to configure these sizes. For example, Gforth has the following command line options:

-d SIZE, --data-stack-size=SIZE   Specify data stack size
-f SIZE, --fp-stack-size=SIZE     Specify floating point stack size
-r SIZE, --return-stack-size=SIZE Specify return stack size
-l SIZE, --locals-stack-size=SIZE Specify locals stack size

[SirWumpus]

A good choice is to provide a way to configure these sizes.

Yes. I already do similar.

As a side note, I read some where (can't find the article now, so probably just misremembering) that Charles Moore found he could work with a very small data stack like 4 or 6 cells. That article and the fact the standard and draft refrained from "stating a number" prompted me to ask the question.

Thank you @ruv.

[pebhidecs]

On 14/02/2023 at 2:18 PM, "Anthony Howe" ***@***.***> wrote: > A good choice is to provide a way to configure these sizes. Yes. I already do similar. As a side note, I read some where (can't find the article now, so probably just misremembering) that Charles Moore found he could work with a very small data stack like 4 or 6 cells. That article and the fact the standard and draft refrained from "stating a number" prompted me to ask the question. Thank you @ruv.

In Chuck's book 'Programming a Problem Oriented Language' on pages 57 and 58, he gives the minimum as 8 for the Return and 16 for the Parameter stack. Regards Paul E. Bennett IEng MIET Systems Engineer Lunar Mission One Ambassador -- ******************************************************************** Paul E. Bennett IEng MIET..... Forth based HIDECS Consultancy............. Mob: +44 (0)7811-639972 Going Forth Safely ..... EBA. www.electric-boat-association.org.uk.. ********************************************************************

[gordonjcp]

That doesn't sound a lot, but I guess if you've got 16 things on the parameter stack you're dangerously close to losing sight of what you're trying to do.

[bfox9900]

I think Stack Machines by Koopman talked about 18 as a a realist data stack size for Forth, based on testing different programs.

It's also probably worth noting that Chuck is also fond of building circular (wrap around) stacks in his hardware.
And in machine Forth he made use of tail call optimization which could keep the return stack needs lower since so much of Forth is a call to another word.

[MitchBradley]

Acceptable stack depth totally depends on what you are trying to accomplish. If you are making a small system that is doing a simple computation, a few cells is probably enough. But for a large system like Open Firmware, where you have extensible driver hierarchies that could be deeply nested and cannot be predicted in advance, you can end up needing hundreds or thousands of cells. Forth is not only for toy programs.

[CCurl]

The higher level your words get, the more nested the supporting words get. So even though any given word might use only 2-3 stack slots, it can execute words that also use maybe 2-3 stack slots, and those words could call lower level words that do the same, and so on. So I can imagine how, during all that nesting, the stack might end up needing to be bigger than initially imagined, simply because of the level of nesting.

[spelc]

Let me echo Mitch's comment. MPE has used stack defaults ranging from 16 bytes to 4 MegaBytes (or more in special cases). This is all dependent on use case, CPU and operating system.

We have systems in the wild that demand error recovery inside nested Windows operating system callbacks. Recovery has occurred at a nesting level of 12. Clients can be very determined.