unset() is not free(). PHP uses memory manager that does the actual garbage cleanup during request shutdown.

So there is simply no way at all to delete / free / unset variables in PHP? But why does it work perfectly (i.e. like I imagine it should) when I unset a string, even a very large one? That one frees the memory instantaneously. But not so for arrays.

I simply cannot see the reasoning behind this. When a programmer calls unset he seems to know that this very variable can be freed, or not? So why do we need to wait for a GC to step in and do the actual cleanup? As far as my limited knowledge goes manual delete/free is compatible with a GC, or not? Or is it only possible to free simple strings, ints etc. but not arrays?

Take this code:

~~~~
<?php
function foo() {
    $string  = '';
    for ($i = 0; $i < 1000; ++$i) {
        $string .= 'asdfasdfasdf';
    }
}

$i = 0;
echo "setup:\t".memory_get_usage()."\n";

for (; $i < 10; ++$i) {
    foo();
    echo "run $i:\t".memory_get_usage()."\n";
}
~~~~

Output:
setup:  65524
run 0:  66108
run 1:  66184
run 2:  66248
and constant thereafter.

If I know change the code slightly:
~~~~
<?php
function foo() {
    $array  = '';
    for ($i = 0; $i < 1000; ++$i) {
        $array[] = 'asdfasdfasdf';
    }
}

$i = 0;
echo "setup:\t".memory_get_usage()."\n";

for (; $i < 10; ++$i) {
    foo();
    echo "run $i:\t".memory_get_usage()."\n";
}
~~~~

The output becomes:
setup:  65364                                            
run 0:  130356                                           
run 1:  130364                                           
run 2:  130384                                           
run 3:  130344
and thereafter either that value or 130364

Ok - it's not a leak per se, yet I wonder: A function I called which setup an array should free that memory (or should get its memory freed) after stepping out of it's scope, no? Just like it does with strings...

Also: I can append the following code to the last snippet to verify that the memory is _never_ freed:
~~~~
while (true) {
    echo memory_get_usage()."\n";
}
~~~~
I actually altered it a bit to break when the memory consumption changes, and could potentially wait for hours.

So is this really no bug? Could it not be that e.g. some internal hash pointers are left behind without getting deleted?

The internal memory manager is keeping tabs of the memory and will reuse 
it again if there is a memory allocation that it can fit in the block.

You can use valgrind and see that the memory is in fact free'd when the 
request ends.

Yes, thank you. Thats an explanation which clarifies things for me.

Though one last thing: I was not speaking about a memory leak which
persists after the process is finished, but one while the process is
running. I was interested because while optimizing GeSHi I searched
for ways to reduce the memory consumption / memory peaks and spotted
this behaviour.

You can close this bug. Thanks again.