- Do the three subroutines operate on a common piece or set of data?
If not, there is no point in making your 3 subroutines (class) methods of an uninstantiable class.
- If so, is there any benefit to caching the data they process (as instance data)?
If the data is passed in, processed, returned, then used and/or disposed of, there maybe no point in caching it.
On the other hand, if the data is accumulate slowly externally, then processed through one sub, retrieved and retained unmodified, and then later passed again to one or more of the subs, it may make sense to accumulate the data into an object instance, call methods on that object instance and only retrieve it once the data has been completely processed.
- Will you need to maintain more that one piece or set of data used (separately) by the subs at once?
A one-instance (at a time) class can be useful, but is less obviously desirable than one where mutliple instances exist at one time.
- How much work do the subroutines do when you call them?
If they only do some small amount of processing each time, but are called many, many times, then any extra overheads involved in using OO rather than subroutines will be magnified.
If the subs/methods do a reasonably substantial amount of processing at each call, then the (fixed) overheads will becomes insignificant, but if each call does only a small amount of processing, the overhead can become a substantial part of your processing time.
If you decide to go the OO route, then there are several flavours of OO construction possible. Which is appropriate will depend upon the performance of your hardware and the time constraints of your application, along with other more esoteric considerations like 'OO-purity', 'maintainance' and inheritability.
By way of crude demonstration, the following benchmark uses subroutines exported from a module ('subs'), and five flavours of OO, (OO1 .. OO5) with increasing levels of 'OO-ness', to do the same thing. The -N=nn parameter represents the amount of work done within each call, with low numbers being a small amount and larger numbers, more:
As you can see, subroutines are quicker than even the simplest level of OO, though at the highest levels of work/call, the difference between subs and the simple forms of OO are negligable. And in these cases, the potential maintainance benefits derivable from OO may well be your deciding factor. Whether the OO-purity arguments should be weighted into you considerations will probably depend upon the performance requirements of your application.
You pay's your money and takes your choice.
#! perl -slw
use strict;
use Benchmark qw[ cmpthese ];
use Dummy1;
use Dummy2;
use Dummy3;
use Dummy4;
use Dummy5;
use Dummy6;
our $N ||= 100;
our @data = 1 .. $N;
cmpthese -3, {
subs=> q[
my @modified = sumem( reversem( @data ) );
],
OO1 => q[
my $obj = new Dummy2;
my @modified = $obj->sumem( $obj->reversem( @data ) );
],
OO2 => q[
my $obj = new Dummy3( @data );
$obj->reversem;
my @modified = $obj->sumem;
],
OO3 => q[
my $obj = new Dummy4( @data );
$obj->reversem;
my @modified = $obj->sumem;
],
OO4 => q[
my $obj = new Dummy5( @data );
$obj->reversem;
my @modified = $obj->sumem;
],
OO5 => q[
my $obj = new Dummy6( @data );
$obj->reversem;
my @modified = $obj->sumem;
],
};
Dummy1.pm
use strict;
package Dummy1;
our @ISA = 'Exporter';
our @EXPORT = qw[ sumem reversem ];
sub sumem {
my $sum += $_ for @_;
return $sum;
}
sub reversem {
return map{ scalar reverse } @_;
}
1;
Dummy2.pm
#! perl -slw
use strict;
package Dummy2;
sub new {
my $class = shift;
return bless [], $class;
}
sub sumem {
my $self = shift;
my $sum += $_ for @_;
return $sum;
}
sub reversem {
my $self = shift;
return map{ scalar reverse } @_;
}
1;
Dummy3.pm
#! perl -slw
use strict;
package Dummy3;
sub new {
my $class = shift;
return bless [ @_ ], $class;
}
sub sumem {
my $self = shift;
my $sum += $_ for @{ $self };
return $sum;
}
sub reversem {
my $self = shift;
@{ $self } = map{ scalar reverse } @{ $self };
}
1;
Dummy4.pm
#! perl -slw
use strict;
package Dummy4;
sub new {
my $class = shift;
return bless { data => \@_ }, $class;
}
sub sumem {
my $self = shift;
my $sum += $_ for @{ $self->{ data } };
return $sum;
}
sub reversem {
my $self = shift;
@{ $self->{ data } } = map{ scalar reverse } @{ $self->{ data } }
+;
}
1;
Dummy5.pm
#! perl -slw
use strict;
package Dummy5;
sub new {
my $class = shift;
my $self = bless {}, $class;
$self->_setData( @_ );
return $self;
}
sub _getData {
my $self = shift;
return @{ $self->{ data } };
}
sub _setData {
my $self = shift;
return @{ $self->{ data } } = @_;
}
sub sumem {
my $self = shift;
my $sum += $_ for $self->_getData();
return $sum;
}
sub reversem {
my $self = shift;
$self->_setData( map{ scalar reverse } $self->_getData() );
}
1;
Dummy6.pm
#! perl -slw
use strict;
package Dummy6;
my %dummies;
sub new {
my $class = shift;
my $self = bless {}, $class;
$dummies{ $self } = {};
$self->_setData( @_ );
return $self;
}
sub _getData {
my $self = $dummies{ +shift };
return @{ $self->{ data } };
}
sub _setData {
my $self = $dummies{ +shift };
return @{ $self->{ data } } = @_;
}
sub sumem {
my $self = shift;
my $sum += $_ for $self->_getData();
return $sum;
}
sub reversem {
my $self = shift;
$self->_setData( map{ scalar reverse } $self->_getData() );
}
1;
