Here is a test snippet where you can prove to yourself that Perl does re-use its own memory space. The following snippet maintains a continuous loop where 10,001 hash elements are assigned integer values, and then the hash falls from scope and is recreated again. If the same memory isn't reused by Perl, it should take no time at all for this snippet to fill all available memory. But as I watch Perl's memory usage in the Windows Task manager, it never jumps above about 4,300k, so my test doesn't reproduce your issue. At least in this case, Perl does the right thing.

use strict;
use warnings;
while (1) {
    my %hash;
    @hash{0..10000} = (0..10000);
}
[download]

By the way, (this is completely unrelated to your question) this snippet does get me a little wierd error intermittantly upon termination with a CTRL-C break:

Terminating on signal SIGINT(2)
Terminating on signal SIGINT(2)
Attempt to free unreferenced scalar: SV 0x188d214 at C:\Perl\Scripts\m
+ytest.pl line 9.
[download]

...line nine is the line with the hash slice on it. I'm using Active State Perl 5.8.2, binary build 808. The error occurred twice out of a few dozen repeated attempts. Of course this error is unrelated to your question, but curious nevertheless.

Perl 5.8.0 does however have a few known memory leaks - I suggest you check to see if your bug is mentioned on http://rt.perl.org. Googling for "perl 5.8.0 memory leak" may also prove useful. One thing you may find is that it's not your hashes that are leaking - as you haven't told us what else you do in your code, it's hard to say. (It's been reported that in some perl versions, simply having a versioned "use" statement in a loop will end up leaking memory)

I'll add what another poster here said - see if you can reduce the code to a simple example that leaks and that you can post.

Your statement that you have to undef your hashes, to me, says you're not properly scoping your variables. If you properly scope your variables to the tightest-scope, Perl will do all the garbage collection for you.

Real-life circular data structures are most easily demonstrated by the following:

my %child = (
    a => 1,
);
my %parent = (
    child => \%child,
);
$child{parent} = \%parent;
[download]

Now, unless you explicitly break the circular reference (or use WeakRef), the memory used by %child and %parent will stick around until the process is done, even if the variables are out of scope.

Alternatively, is there anyway to monitor the memory space during execution to identify any uncollected/leaking memory ?

You might want to look at Test::Memory::Cycle and Devel::Cycle to check for circular references.

#!/usr/bin/perl

use Devel::Size 'total_size';

my %struct = ("key1" => ["bill","ben"],
             "key2" => ["dave","jen"]);

print "total size of %struct - ", total_size(\%struct),"\n";
[download]

#update last viewed timestamp  
     $info{$key_prev}{'timestamp'} = time;
[download]

if(defined $info{$key_prev}){
   #update last viewed timestamp  
     $info{$key_prev}{'timestamp'} = time;
[download]