I'm not sure what you're asking. For any given variable, you can release its contents using undef. This is true regardless of the variable's scope (i.e., it's true for globals and lexicals both).

my $scalar = 'scalar of doom';
my @array = qw( things I want to forget );
my %hash = ( preservation_required => 'false' );

undef $scalar;
undef @array;
undef %hash;
[download]

oww thanks... it solves my little problem.

In general, you won't be able to completely undefine a hash (memory wise), you can only clear out it's data and keys (but Perl will still retain the allocated memory for future use).

Normally the rule is: you need to undef the variable before it goes out of scope. It works for arrays and strings, but not with hashes.

#!/usr/bin/perl
use strict;
use warnings;
# array reclaims mem 

show_size();

{
    my @var=(0..1000000);
    show_size();
    undef @var;
}

show_size();
exit(0);

sub show_size {
    local $/;
    open(my $pfh, '<', "/proc/$$/status") || die $!;
    my $size = <$pfh> =~ /VmSize:\s+(\d+)/
               ? $1
               : 'unknown';
    close($pfh);
    print "Process size: $size\n";
}
[download]

#!/usr/bin/perl
use strict;
use warnings;

# dosn't work well with an hash

show_size();

{
    my %hash;

    for(0..1000000){
      $hash{$_}= 'perlperlperl';
    
    }
    
    show_size();
    
    foreach(0..1000000){
      $hash{$_}= '';
      undef $hash{$_};
    }
    
    undef %hash;
}

show_size();

exit(0);

sub show_size {
    local $/;
    open(my $pfh, '<', "/proc/$$/status") || die $!;
    my $size = <$pfh> =~ /VmSize:\s+(\d+)/
               ? $1
               : 'unknown';
    close($pfh);
    print "Process size: $size\n";
}
[download]

a hash is unsorted (jumbled) type of a data structure. so does it happen sometimes that creating a new hash would replace another allocated memory?

I have a suspicion that you've asked a question in a way that's elicited an misleading answer from zentara. It's true what he said about unreferenced things possibly being interleaved in memory but generally speaking this doesn't matter. In normal perl you never have to deal with memory management issues like allocation and only in unusual circumstances, deallocation. Perl is never going to re-use memory that is still in use by something else. If that's your worry, you're safe. Also, you don't have to take steps to inform perl that data structures may be deallocated. Perl's reference counting is frequently good enough though it has no way to deal with cyclic structures.

The only time you ought to find it necessary to be specific about freeing memory is when you're leave code you don't intend to re-enter again and it is somehow important to you to remove the empty containers. This sometimes comes up when you've got some very large hashes or arrays and you know you're not going to use it again and the memory is significant enough to notice. In that circumstance, you can use the undef() function on your variables and it will delete the containers. Normally perl will just clear away the data within your containers because often you're going to be re-using them when you're in a subroutine or a loop.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

That is pretty much how it works. Perl will save the old memory for reuse, and the new hash will use that left over memory. If you make the hash a global, and "clean it out", it will reuse the same mem over and over, and memory usage will rise to the "peak" level of the biggest hash. Perl (and almost any other program) will not release memory back to the OS.... it figures if you used it once, you may need it again, so it holds on to it. If you want to release the mem back to the OS, use C (which will allow you to deallocate the mem), or "fork and exec" the subroutine, and mem will be truly released at the end of the exec.

---

I'm not really a human, but I play one on earth. Cogito ergo sum a bum