From time to time I enjoy tackling Project Euler problems (106 solved to date). Over the years I’ve developed the following routine: I start a new solution in a separate file named, say, Problem_42.pm which begins like this:

package Problem_42;

use strict;
use warnings;
...
main() unless caller;

sub main
{
    # local timing code
    my $solution = solve();
    # print solution and time taken
}

sub solve
{
    ...
    $return solution;
}
...
1;
[download]

That way I can run the solution code directly as perl Problem_42.pm and get a nice output message, or I can call the module from a test script which gets only the solution:

# test.pl
...
use Test::More;
...
# Create %problems and populate with names and solutions keyed to prob
+lem numbers
...
for my $i (sort { $a <=> $b } keys %problems)
{
    my $module = 'Problem_' . $i;
    require $module . '.pm';

    my $time0  = time();
    my $result = ${module}->solve();
    my $time1  = time();

    printf "%3d (%2d s): ", $i, int($time1 - $time0 + 0.5);

    is
    (
        $result,
        $problems{$i}->{solution},
        $problems{$i}->{name} . ': answer'
    );

    print ' ' x 12;

    cmp_ok
    (
       ($time1 - $time0),
       '<',
        MAX_SECONDS,
        $problems{$i}->{name} . ': time'
    );
}

done_testing();
[download]

This works fine, except that sometimes when I add a new solution it affects the way the other modules perform.

In one such case I added a solution and found that a subsequent solution had speeded up considerably. I believe this is due to memory allocation: the new solution used heap memory which was still available when the subsequent module was run, and it so happened that the later module was adding to its available memory in increments, so with that memory already available the overhead of repeated allocations was substantially reduced.

But I have been operating on the assumption that by putting each solution into its own namespace (i.e., package), I have isolated it semantically from the other solutions. It now appears that this is not the case. Adding a module with a use bignum pragma causes a subsequent module to perform incorrectly, even though the pragma is in a separate package and the later module has the correct use declarations..

• Windows 8.1, 64-bit
• Strawberry Perl versions 5.20.2, 5.22.1, and 5.24.0, all 64-bit and built with USE_64_BIT_INT
• bignum versions 0.37, 0.42, and 0.42, respectively
• Math::BigFloat versions 1.9993, 1.999722, and 1.999722, respectively.