comment on

I ran some benchmarks, which might be of interest. I compared the node object for http://search.cpan.org/~rvosa/Bio-Phylo-0.04/lib/Bio/Phylo/Trees/Node.pm (actually, for the next version, with a different namespace, but the guts are the same), which uses an anonymous hashref, to the one below:

package Outside::In;
use strict;
use warnings;
use Carp;
use Scalar::Util qw(looks_like_number);
use overload '""' => \&to_string;
{
    my @name;
    my @parent;
    my @first_daughter;
    my @last_daughter;
    my @next_sister;
    my @previous_sister;
    my @branch_length;
    my @reclaim;
    my $obj_counter = 0;
    
    sub new {
        my $class = shift;
        my $instance_counter = 0;
        if ( @reclaim ) {
            @reclaim = sort { $a <=> $b } @reclaim;
            $instance_counter = shift(@reclaim);
        }
        else {
            $instance_counter = $obj_counter;
            $obj_counter++;
        }
        my $self = \$instance_counter;
        bless $self, $class;
        return $self;
    }
    
    sub set_parent {
        $parent[${$_[0]}] = $_[1] if $_[1];
        return $_[0];
    }
    
    sub get_parent {
        return $parent[${$_[0]}];
    }
    
    sub to_string {
        return 'ObjectID = ' . ${$_[0]};
    }

    sub DESTROY {
        delete $name[${$_[0]}];
        delete $parent[${$_[0]}];
        delete $first_daughter[${$_[0]}];
        delete $last_daughter[${$_[0]}];
        delete $next_sister[${$_[0]}];
        delete $previous_sister[${$_[0]}];
        delete $branch_length[${$_[0]}];
        push(@reclaim, ${$_[0]});
    }

}

package main;
use strict;
use warnings;
use Benchmark qw(:all);
use Bio::Phylo::Forest::Node;
use Data::Dumper;

my $oldnode1 = Bio::Phylo::Forest::Node->new;
my $oldnode2 = Bio::Phylo::Forest::Node->new;
$oldnode1->set_parent($oldnode2);

my $newnode1 = Outside::In->new;
my $newnode2 = Outside::In->new;
$newnode1->set_parent($newnode2);

cmpthese (1000000, {
    'old' => sub { $oldnode1->get_parent },
    'new' => sub { $newnode1->get_parent }
});
[download]

Result:

        Rate  old  new
old 477555/s   -- -34%
new 723066/s  51%   --
[download]

The salient point is that:

sub get_parent {
    return $_[0]->{'PARENT'};
}
[download]

seems quite a bit slower than:

sub get_parent {
    return $parent[${$_[0]}];
}
[download]

I've heard that array look-ups are faster than hash look-ups, but I thought the difference was smaller than it is.

In reply to Re: inside-out objects using arrays? by rvosa
in thread inside-out objects using arrays? by rvosa

Are you posting in the right place? Check out Where do I post X? to know for sure.
Posts may use any of the Perl Monks Approved HTML tags. Currently these include the following:
<code> <a> <b> <big> <blockquote> <br /> <dd> <dl> <dt> <em> <font> <h1> <h2> <h3> <h4> <h5> <h6> <hr /> <i> <li> <nbsp> <ol> <p> <small> <strike> <strong> <sub> <sup> <table> <td> <th> <tr> <tt> <u> <ul>
Snippets of code should be wrapped in <code> tags not <pre> tags. In fact, <pre> tags should generally be avoided. If they must be used, extreme care should be taken to ensure that their contents do not have long lines (<70 chars), in order to prevent horizontal scrolling (and possible janitor intervention).
Want more info? How to link or How to display code and escape characters are good places to start.


go ahead... be a heretic
	PerlMonks