in reply to Re^4: Enforce Memory Cleanup
in thread Enforce Memory Cleanup

Each iteration through outer while loop creates a new %map, and at the end of each outer while loop, that %map should be falling out of scope, at which time it should be garbage collected. However, you are passing a reference to that hash to process(), and we have no idea what you're doing with that reference. That subroutine could possibly be doing something that causes the reference count to the hash to never fall to zero, so it never gets garbage collected.

Here's a trivial example:

while( 1 ) { my %hash = ( this => 1, that => 2 ); process(\%hash); } sub process { my $href = shift; $href->{me} = $href; }

Run that and watch as your memory usage climbs. On each iteration of the while loop a new lexically scoped hash is created. And at the end of each iteration, it falls out of scope and could be garbage collected, except that you passed a reference to it to process(). And process() is doing something nasty; it's creating an element in the %hash that references the same hash. This is a circular reference, and it prevents the hash's ref count from ever dropping to zero.

What's even worse in this case is that as soon as %hash falls out of scope, it's lost; there are no external variables holding a reference to it. The hash is self-referential, and unreachable.

This is pretty contrived, but just an example of where the trouble can come from. More often (in the real world), some complex arrangement of objects leads to a circular reference that nobody considered until the server started bogging down every day or two.