Circular references and PHP's memory management

When loading objects and collections that are related to each other, Cough automatically backlinks certain things to others to keep resource usage to a minimum, rather than duplicating the object in memory for all instances where they link up... Example:

foreach($collection as $element) {
        $element->setWhatever_Collection($this);
}

However, if you happen to be running a loop of things, and instantiating a collection into the same variable name over and over, i.e.:

foreach($some_Collection as $element) {
        $someOther_Collection = SomeOther_Collection::loadNonRetired(array(
                'foreign_key_id' => $element->getKeyId()
        ));

        // do some other stuff with $someOther_Collection
}

Obviously, this is bad coding practice, but is done in some situations nonetheless... The problem is that PHP's memory management won't reclaim any of the memory used in this situation, when the $someOther_Collection variable is overwritten and eventually goes out of scope...

Garbage collection only reclaims memory when there are no outstanding references to it, so even if you explicitly unset($someOther_Collection), memory is still lost to the system, because within $someOther_Collection are objects that are backlinked to the collection itself... All you've done is orphaned the memory when you unset your reference to that variable... This happens for all CoughObject and CoughCollection class items when they've loaded any data that points back to themselves, and they're unset or go out of scope, PHP can't reclaim the memory used on them...

The solution is simple, add destructors to both the CoughObject and CoughCollection classes to recursively unset all references in their objects and collections members, like so:

abstract class CoughObject {
        public function __destruct() {
                foreach($this->objects as $object) {
                        unset($object);
                }

                foreach($this->collections as $collection) {
                        unset($collection);
                }
        }
}

abstract class CoughCollection extends ArrayObject {
        public function __destruct() {
                foreach($this as $object) {
                        unset($object);
                }
        }
}

The destructors will fire off anytime a variable goes out of scope, is overwritten, or is explicitly unset(), and will recursively destroy their way down to the bottom of any other nested objects or collections, allowing that memory to be reclaimed by the system... This is PHP bug #33595 (http://bugs.php.net/33595), and has been deemed "not very critical, because all memory is freed on request shutdown" as of 5 years ago, so I don't see them implementing their own fix anytime soon :D