Tue, 19 Feb 2008
The Cost of Flexibility (and Cleanliness)
In the previously mentioned distributed computing project, I am trying to do something like the following code:
sub parse_file {
my $fh = shift;
while (my $parsed_data
= nontrivial_get_data_from($fh)) {
handle($parsed_data);
}
}
The nontrivial_get_data_from($fh) code
is indeed non-trivial (in the terms of lines of code, not necessarily
in the terms of CPU time), while handle($parsed_data)
is pretty straightforward. Now the problem is that I want to use this
non-trivial code with different handle($parsed_data)
routines (for example, printing out the $parsed_data for
testing purposes). A natural way would be to implement a pure virtual
class in which the $self->handle($parsed_data) routine
would be called inside the parse_file() method, and which
the programmer would subclass, providing different $self->handle()
implementations.
I have found that using a subclassed method $self->handle()
instead of putting the handling code directly into parse_file()
costs about 14 % of time (the dirty inlined code took 35 seconds on the
test data set, while the nice and clean subclassed one took 40 seconds).
So, my dear Perl gurus, how would you implement this? I need to call different
code in the innermost loop of the program, and just factoring it out
into the subroutine (or a virtual method) costs me about 14 % of time.
Maybe some clever eval { } and precompiling different instances
of parse_file()? In fact I don't really need the flexibility
of objects: I need only a single implementation of
handle($parsed_data) in a single program run, but I want to
be able to use a different handle() code with the
same parse_file() code base called from different programs.