One Allocator Adds a Number, the Other Goes Looking

A register holds the address of the top of the current stack. Entering a

function subtracts the size of its local variables from that register, and

everything the function declares lives in the region that just appeared.

Returning adds the same number back.

That is the entire mechanism. There is no list of allocations, no record of

sizes, no search for a suitable gap, and no way for two threads to interfere,

because each thread has its own. Allocating a kilobyte and allocating a byte

cost exactly the same, which is one instruction.

The addresses it produces are the best possible ones for everything in the

last three lessons. Successive frames are adjacent, the memory was almost

certainly used moments ago by a previous call, and so it is already in cache

and already translated. Stack memory is fast in two different ways and the

second one is larger.

What the mechanism cannot do is free out of order. The only operation is

moving the top, so the thing allocated last is freed first, always. If

something must outlive the function that created it, the stack cannot hold

it, and this is not an implementation limit that a better design could remove.

It is what makes the addition and subtraction sufficient.