Song Stone Glitch Explanation

About Object/Actor Memory Management:

Location in game memory: 80935650 - 815245A0 (12.42 MB total)

DYN Space: 80935650 - 80AD4580 (1699632 Bytes = 1699.63 KB = 1.7 MB)
ACT Space: 80AE9E10 - 815245A0 (10725264 Bytes = 10725.26 KB = 10.73 MB)

-The game has 2 memory spaces for actor data which I dubbed the ACTor space (big; used for file data) and DYNamic space (small; for dynamic actors such as rupee spawns; stores instances of loaded actors with their runtime variables; can be used as backup space in case the ACT space runs out)
-Space gets filled up like a double linked list from top-bottom
-Each entry points to the prior and next one. Free space has a size parameter so the game knows immediately how much can fit there
-A separate list of loaded actors (by name) keeps track of the amount of times actors exist in the game. If the game attempts to construct an actor the counter gets increased by 1, if it gets destroyed the counter is reduced by 1. An actor gets destroyed either when you kill an enemy for example, hit a loading zone or leave the room (the actor gets destroyed after the door closes which occurs AFTER the next room loaded)
-Once 0 instances of an actor remain in the game the memory space associated with it is declared as free (the game notes how big the space is) and the entry is wiped from the loaded actors list
-Once you open the next door the memory manager will attempt to merge the free space with other adjacent free memory blocks which only works if there is no used memory block in-between. This process happens shortly after the next room was loaded and is intended to keep as many big memory blocks as possible and avoid a lot of smaller ones. So if you have actors loaded from room 1, the space gets declared as free in room 2 if the actor is not used in that room as well. Finally in room 3 the space will be merged as best as possible. If you kill all instances of an actor (in this case an enemy) in room 1, the space will already be declared free while you are still in room 1. Thus the memory will be merged in room 2 instead
-Going through many rooms will naturally cause some fragmentation of this list leaving many smaller blocks in-between that can't be merged until you hit a loading zone in which case everything gets cleared
-When a new actor needs to be loaded, the game loops through the list from top to bottom and tries to find a big enough slot to fit the data in. If an actor is too big to fit into any of them including the remaining memory at the very bottom of the list (which can only realistically happen with fragmentation and many actors loaded at the same time), the game throws an allocation error
-A failsave kicks in and the game attempts to reserve space in the DYN space instead (this space doesnt get touched by file data otherwise)
-If the DYN space is already filled as well the game throws a second allocation error and finally an archive mount error. All space is filled up or there is not a big enough slot to fit the data in, the actor can not be loaded
-Due a programming oversight the instance counter will still be increased, but since no actor was actually spawned, no destroy process will occur if you leave the room or hit a loading zone. Thus the instance counter can only rise and will never hit 0. This creates a dead actor that will never be cleared from the loaded actor list and has no data associated with it. Thus when the game attempts to spawn an instance of that actor in the future it will already find the entry in the list and assume the actor was loaded, but since there is no pointer to any memory space the spawn process will always fail. Even if plenty of memory space is available later, the game won't attempt to load the actor object again. This can only be fixed by either overflowing the instance counter to set it back to 0 or reboot your console
-Furthermore, the game only has 64 total slots to store loaded actor names. If you happen to fill up this list to the max by creating a bunch of dead actors, no actor can be loaded anymore period. This includes the barrier


Wind Temple/Song Stone case:

Video showing the glitch happening: https://www.youtube.com/watch?v=2-RO4TcChr8

-ACT space fills up (and gets fragmented) if you go through the entire temple and reach the room before the song stone (even without anything stored)
-Due to too much fragmentation/actors loaded the game can't allocate enough space anywhere for the Bokoblin actor data inside the room before the song stone. An allocation error is thrown. Game switches to the DYN space and finds enough space to store the actor data there
-After the room before the song stone loaded, the unloading/merging process of unused actors/memory space from previous rooms frees up enough space again for the song stone actor (if you dont store a chest)
-Storing a chest fragments the memory even more since in this case the butterfly pendant model has to be loaded and can't be cleared. This is due the instance counter remaining at 1 until you savewarp/hit a loading zone which destroys it. So that piece of memory can't be cleared and merged with other adjacent free memory while you are moving inside the dungeon. It just so happens that having this setup puts the pendant roughly in the middle of the remaining memory which results in the merging process not being able to do much since it is in the way. Thus none of the remaining slots are big enough to fit the song stone actor
-Now the ACT space is filled up/fragmented and the reserve in the DYN space is used as a failsave for the Bokoblin actor
-While attempting to load the song stone in this situation the game throws an allocation error for the ACT space, tries the DYN space and throws a second allocation error. The game now gives up and finally throws an archive mount error


General Stuff:

-This glitch will only work well with big actors (file size wise), since smaller ones would still fit most of the time into one of the slots
-Savewarping/hitting a loading zone will clear most space and fix potential problems/fragmentation. So this glitch will only work well in dungeons/overworld
-Storing multiple chests can only create more fragmentation if the content is different, else you just increase the instance count. It can also lead to the game actually creating bigger slots depending where the second stored chest goes. In the case of Wind Temple storing two different chests can prevent the glitch due different alignment that works out in the games favour
-Door storage can also help to reduce available memory space
-Most of this applies to TP as well and could be the cause of the Devil/Ben cs glitch