Three things are loaded into the part of the heap that we're interested in:
 1. Heap nodes (have size 0x10 in MM)
 2. Actor instances (labelled "AI" in spectrum)
 3. Actor Overlays (labelled "AF")

===HEAP NODES===
Heap nodes are size 0x10 files that sit between all loaded actors, and surround gaps that new actors can be allocated into. In this way, nodes are used to keep track of the size of gaps in the heap for easy allocation.

Whenever an instance or overlay loads into the heap, the nodes are checked. The first node is checked first, if it has enough free space directly after it then it will allocate there. If not, it will go onto the next node and check there - and so on until it finds a spot.

Once it finds a spot, the file will allocate there and will check if it needs to place a node. Nodes will always stick around if there is a file allocated either directly before them or directly after them (or both). So you will never find a file which isn't sandwiched by two nodes, even if there's a gap in the heap.

For example, let's say the heap looks like this:

Node
Actor0 (Size 0x100)
Node
Free space (Size 0x120)
Node
Actor0  (Size 0x100)
Node

And let's say we want to load another Actor0 into the heap. The first available node would be the one before the free space, and an Actor0 instance would fill up 0x100 of the space. A node would then be placed on the end of Actor0 and we would end up with:

Node
Actor0 (Size 0x100)
Node
Actor0
Node
Free space (Size 0x10)
Node
Actor0  (Size 0x100)
Node

But let's say we wanted to load in the actor Actor1 which has size 0x110. Clearly there's enough room there, but if we try to place a node directly after it, we would end up with two nodes next to each other, which is pretty useless as there's no space between them.

What happens instead is that the node before the new actor will essentially just treat the actor as if it has size 0x120 instead of 0x110, so that it perfectly fits in the gap. In this way we can find inconsistencies in the amount of space actors take up on the heap.

===OVERLAYS===
Overlays contain a lot of the functions for how actors should run. An overlay will always allocate in earlier (in time) than the instance - essentially the overlay being on the heap is a prerequisite for the instance.

There are three types of allocation for overlays:
0: The overlay allocates into the earliest spot it can on the heap
1: The overlay allocates into the end of the heap, as far as it can go
2: The overlay allocates to the end, and will never deallocate until you reload a scene.

For types 0 and 1, the overlay will de-allocate if all the instances disappear. 2 will not.  Most actors have type 0 overlays, but most actors that are spawned by link (bombs, chus, quickspin effect) will have type 2.

The one exception is the item pickup actor which (at least in OoT) doesn't actually have an overlay because it checks some static code elsewhere in memory instead.