Memory management in Forth

Question

So I\'m just learning Forth and was curious if anyone could help me understand how memory management generally works. At the moment I only have (some) experience with the C stac

Answer 1

The fundamental question may not have been answered in a way that a new Forth user would require so I will take a run at it.

Memory in Forth can be very target dependant so I will limit the description to the simplest model, that being a flat memory space, where code and data live together happily. (as opposed to segmented memory models, or FLASH memory for code and RAM for data or other more complicated models)

The Dictionary typically starts at the bottom of memory and is allocated upwards by the Forth system. The two stacks, in a simple system would exist in high memory and typically have two CPU registers pointing to them. (Very system dependant)

At the most fundamental level, memory is allocated simply by changing the value of the dictionary pointer variable. (sometimes called DP)

The programmer does not typically access this variable directly but rather uses some higher level words to control it.

As mentioned the Forth word 'HERE' returns the next available address in the dictionary space. What was not mentioned was that HERE is defined by fetching the value of the variable DP. (system dependancy here but useful for a description)

In Forth 'HERE' might look like this:

: HERE ( -- addr) DP @ ;

That's it.

To allocate some memory we need to move HERE upwards and we do that with the word 'ALLOT'.

The Forth definition for 'ALLOT' simply takes a number from the parameter stack and adds it to the value in DP. So it is nothing more than:

: ALLOT ( n --) DP +! ; \ '+!' adds n to the contents variable DP

ALLOT is used by the FORTH system when we create a new definition so that what we created is safely inside 'ALLOTed' memory.

Something that is not immediately obvious is the that ALLOT can take a negative number so it is possible to move the dictionary pointer up or down. So you could allocate some memory and return it like this:

HEX 100 ALLOT

And free it up like this:

HEX -100 ALLOT

All this to say that this is the simplest form of memory management in a Forth system. An example of how this is used can be seen in the definition of the word 'BUFFER:'

: BUFFER: ( n --) CREATE ALLOT ;

'BUFFER:' "creates" a new name in the dictionary (create uses allot to make space for the name by the way) then ALLOTs n bytes of memory right after the name and any associated housekeeping bytes your Forth system might use

So now to allocate a block of named memory we just type:

MARKER FOO \ mark where the memory ends right now

HEX 2000 BUFFER: IN_BUFFER

Now we have an 8K byte buffer called IN_BUFFER. If wanted to reclaim that space in Standard Forth we could type 'FOO' and everything allocated in the Dictionary after FOO would be removed from the Forth system.

But if you want temporary memory space, EVERYTHING above 'HERE' is free to use!

So you can simply point to an address and use it if you want to like this

: MYMEMORY here 200 + ; \ MYMEMORY points to un-allocated memory above HERE

                        \ MYMEMORY moves with HERE. be aware.

MYMEMORY HEX 1000 ERASE \ fill it with 2K bytes of zero

Forth has typically been used for high performance embedded applications where dynamic memory allocation can cause un-reliable code so static allocation using ALLOT was preferred. However bigger systems have a heap and use ALLOCATE, FREE AND RESIZE much like we use malloc etc. in C.

BF