It seems the DESTROY method doesn't quite work as advertised in this case (i.e. it doesn't destroy all circular references). If you use Data::Dumper; and write

        print Dumper $tree;
        $tree->DESTROY(); #clear circular references
        print Dumper $tree; <STDIN>;
[download]

you can compare the dump before and after the DESTROY call. You'll notice that the _parent attribute of the first-level child nodes has been set to undef, but not those of the children further down in the tree...

Anyway, as the module also allows for weak references to be used, you could also simply write

use Tree::Simple 'use_weak_refs';
[download]

...and be happy :) — Just tried it, no memory leaks any longer.

I really appreciated your answer,
Thank you very much!!


Although the memory usage still increases it’s nothing compared with the situation before “use_weak_refs”. I’ll try to investigate further with the method that you showed.

I usually avoid posting Perl-free nodes like this one... but in this case, I'd just like to say a quick thanks in reverse.  It's always a pleasure to have self-contained code that I can just cut-n-paste and run. That makes me far more inclined to try to replicate the problem and look for a solution... — Thanks, and good luck with finding the remaining leaks!

If the program reached the last return statement why is it going to STEP4 and not to the main function? Could anyone tell me what is going out?

#!/usr/bin/perl -w
use strict;
use Tree::Simple;
#use Tree::Simple 'use_weak_refs';
use Data::Dumper;
#use Devel::Trace;
$Data::Dumper::Indent=1;
#$Devel::Trace::TRACE=0;
 
local $|=1;
my $CR="\n"; 
my $WS="--------------------------------------------------------------
+---$CR";
my @array = qw/ 112.75 850.22 100.65 /;

#for (my $j=0;$j<1;$j++)
#    {
        #always the same code to execute
        my $i=0;
    
        my $tree = Tree::Simple->new("root tree",Tree::Simple->ROOT);
        printleaf(\$tree);
        $tree->addChild(Tree::Simple->new("$array[$i]"));
        printleaf(\$tree->getChild(0));
        my @_auxarray=@array;
        splice(@_auxarray,$i,1);
        
        foreach my $elem (@_auxarray)
        {
            printleaf(\Tree::Simple->new("$elem",$tree->getChild(0)));
        }
        
        undef @_auxarray;
        
        print "${WS}DATA DUMPER: $CR";
        print Dumper $tree;
        print "${WS}";
        
        FULLY_DESTROY($tree);
        
        ###########################STEP 3############################
        print "${WS}DATA DUMPER: $CR";
        print Dumper $tree;
        
        #$tree->traverse(sub { my($_tree)=@_;
                        #print (("\t" x $_tree->getDepth()), $_tree->g
+etNodeValue(),"\n");
                        #});
        
        undef $tree; 
#    }
<STDIN>; #pause

sub printleaf{
    my ($_leaf)=$_[0];
    print("VALUE: ",$$_leaf->getNodeValue()," | ROOT?: ",$$_leaf->isRo
+ot() ? "true" : "false"," | DEPTH: ",$$_leaf->getDepth()," | INDEX: "
+,$$_leaf->getIndex(),"$CR");
}

sub FULLY_DESTROY{
    my ($self)=$_[0];
    
    print ($self->getNodeValue()," ");
    
    while(1)
    {
        ###########################STEP 4############################
        if(!ref($self->{_parent}) && $self->{_parent} eq 'root' && sca
+lar(@{$self->{_children}})==0)
        {
            $self->{_parent} = undef;
            print ("called last to end the sub routine$CR");
            ###########################STEP 1#########################
+###
            last;
        }
        
        if(defined($self->{_children}) && $self->getChildCount!=0)
        {
            print ("childs ",$self->getChildCount(),"$CR");
            FULLY_DESTROY($self->getAllChildren());
        }
        #if has no childs saves the father reference
        my $ref; 
        my $index=$self->getIndex();
        print("index ",$index," ");
        
        if(($index+1) == ($self->getParent()->getChildCount())) #last 
+in the branch
        {
            print ("childs 0 last in branch$CR");
            $ref = \$self->getParent();
            $self->{_parent} = undef;
            @{$$ref->{_children}}=();
            FULLY_DESTROY($$ref);
        }
        else
        {
            print ("childs 0 not last in branch$CR");
            $ref = \$self->getSibling($index+1);
            $self->{_parent} = undef;
            FULLY_DESTROY($$ref);
        }
    }
    ###########################STEP 2############################
    print "end should return to main function$CR$CR";
    return;
}
[download]

a call to return after each recursive call, like:
FULLY_DESTROY($$ref); return;
solves the problem don't ask me why but it works...

You seem to be confused about your program flow. From looking at the call structure of your program, the flow will be

1. Step 1
2. Step 2
3. Step 4
4. Step 3

You have an endless loop in FULLY_DESTROY, which I don't see where you leave it. Maybe that is the reason for why your program does work differently than you expect it to. You would have found this by removing all other things from your program and replacing it by simple statements that just printed out "STEP 1" etc.