$self->{self} = $self;
[download]

Dave.

Not only is it unusual, it is incorrect. Perl itself will call DESTROY for you when it is about to lose its last reference to an object. You should never call the DESTROY method yourself because the object *isn't* being destroyed when you call the function.

Memory allocation and free has been discussed a few times:

• How do I free memory allocated to an array
• Freeing perl memory
• Freeing up memory
• Freeing memory used by arrays
• Not able to release memory
• Another memory usage question
• Garbage Collection and undef

Updated, reordered a little.

As dave_the_m pointed out, putting a copy of $self as an attribute in $self is going to prevent it from being garbage collected. But I have to wonder what the point of doing so is, anyway? The reference to $self is stored in... $self. So to get to $self, you first need to get to... $self. It doesn't make a whole lot of sense. :-)

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

my %bubs;

while(1){
for(1.. 500){
  $bubs{$_} = ZtkBubject->new(
                 -name => $_,
          );
 $bubs{$_}=();
 delete $bubs{$_};
}

%bubs = ();
undef %bubs;
print "\nCheck memory now and hit enter\n";
<>;

}

#=====================================================================
+======== 
#                ZtkBubject  Class 
#=====================================================================
+======== 
package ZtkBubject;
use strict 'vars';
use Carp;

sub new {
    my ($class, %arg) = @_;

        my $self = {
          'name'  => $arg{-name},
       };
bless $self;
#    print "just blessed $self\n"; 
    $self->{stuff} = [1..1000]; #add some memory usage  
return $self;
}
############################################# 
sub DESTROY{
  my ($self) = @_;
   print "destroying->", $self->{name},'  ',$self,"\n";
}
########################################### 
1;
[download]

Er, i hate to say this but i dont think thats a great idea unless you have seriously good reasons.

The way to do this is to make sure the reference that is blessed is not part of the cyclic structure. Consider the following code:

use strict;
use warnings;

sub MyBinTree::insert {
  my ($self,$string,$node)=@_;

  my $ins_ref;
  unless ($node) {
    unless ($self->{root}) {
      $ins_ref=\$self->{root}
    } else {
      $node=$self->{root};
    }
  }
  unless ($ins_ref) {
    if ($string lt $node->{val}) {
      if ($node->{left}) {
        return $self->insert($string,$node->{left})
      } else {
        $ins_ref=\$node->{left};
      }
    } elsif ($string gt $node->{val}) {
      if ($node->{right}) {
        return $self->insert($string,$node->{right})
      } else {
        $ins_ref=\$node->{right};
      }
    } else {
      return $node;
    }
  }
  $$ins_ref={val=>$string,parent=>$node};
  return $$ins_ref
}

sub MyBinTree::new {
  my ($class)=@_;
  my $self= bless { },$class;
  print "Created new $self\n";
  return $self;
}

sub MyBinTree::_traverse {
  my ($self,$node,$sub)=@_;

  if ($node->{left}) {
    $self->_traverse($node->{left},$sub);
  }
  {
    local $_=$node;
    $sub->();
  }
  if ($node->{right}) {
    $self->_traverse($node->{right},$sub);
  }
}

sub MyBinTree::traverse {
  my ($self,$sub)=@_;

  $self->_traverse($self->{root},$sub)
    if $self->{root};
}

sub MyBinTree::DESTROY {
  my $self=shift;
  print "Destroying new $self\n";
  $self->traverse(sub { delete $_->{parent} });
  print "Destroyed\n";
}

{
  my $container=MyBinTree->new();
  $container->insert($_) for (my @words=qw(foo bar baz bop fop cool));
  $container->traverse(sub { print $_->{val},"\n" });
  print "Exiting scope.\n";
}
[download]

Which outputs:

Created new MyBinTree=HASH(0x1acef24)
bar
baz
bop
cool
foo
fop
Exiting scope.
Destroying new MyBinTree=HASH(0x1acef24)
Destroyed
[download]

The internal data structure is entirely self referential and cyclic. Yet it destroys just fine, and with no weakref.

---
demerphq

But even if I remove it, and not call DESTROY myself, and take all references to the objects out of scope, the memory is not reused. So can anyone show how to prevent the memory doubling in the following? I use 2 different hashes, and undef the first, so why isn't the memory available for the second hash to reuse? I would guess that it is somehow not releasing the array's used in $self->{stuff}, but if I put @{$self->{stuff}} = () in the DESTROY sub, it dosn't clear it.

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

my %bubs;
my %bubs1;

for(1.. 500){
  $bubs{$_} = ZtkBubject->new(
                 -name => $_,
          );
 $bubs{$_}=();
 delete $bubs{$_};
 $bubs{$_}=();
}
%bubs = ();
undef %bubs;

print "Check memory now and hit enter\n";
<>;

for(1.. 500){
  $bubs1{$_} = ZtkBubject->new(
                 -name => $_,
          );
}

print "Check memory now and hit enter, its doubled\n";

<>;

#=====================================================================
+======== 
#                ZtkBubject  Class 
#=====================================================================
+======== 
package ZtkBubject;
use strict 'vars';
use Carp;

sub new {
    my ($class, %arg) = @_;

        my $self = {
          'name'  => $arg{-name},
       };
bless $self;
#    print "just blessed $self\n"; 
    $self->{stuff} = [1..1000]; #add some memory usage  
return $self;
}
############################################# 
sub DESTROY{
  my ($self) = @_;
  @{$self->{stuff}} = ();
   print "destroying->", $self->{name},'  ',$self,"\n";
}
########################################### 
1;
[download]