Hi eyepopslikeamosquito,

Oh I wished I had something older to run on. Unfortunately, my laptop is the slowest machine I have. The Haswell/Crystalwell chip has 128MB of eDRAM. It's purpose is for the GPU. But, the 4 cores has access to it as well when the GPU is idle, which is the case while benchmarking Perl. The late 2013 i7-4960HQ CPU runs at 2.6 GHz with turbo-boost at 3.8 GHz. I've forgotten that it could run that high on one core with nothing else running.

I have some news to share. It's possible for tybalt89's excellent optimization to run faster. The extra optimization shaves 6 ~ 7 seconds. Memory consumption reduced as well. I applied the same optimization to the two bit implementations, mine and tybalt89's shorter implementation. For the latter, also applied a change mentioned earlier to not fail with cperl.

# use 30-bits on 64-bit hw for cperl compatibility
my $half = ( ( log(~0 + 1) / log(2) ) >= 64 ) ? 30 : 16;
[download]

Before:

$ perl createblinker.pl 500000 -900000 100 >x.tmp 2>y.tmp
$ perl tbench1.pl x.tmp 2

               mem size   v5.26.0   v5.24.2   v5.22.4   cperl
infinite       7,548 MB  122 secs  119 secs  133 secs  116 secs
original         704 MB  167 secs  168 secs  180 secs  163 secs
improvements     744 MB   57 secs   57 secs   63 secs   54 secs
optimized i2   1,543 MB   38 secs   39 secs   40 secs   36 secs
2 nums into 1  1,510 MB   39 secs   40 secs   42 secs   37 secs
shorter impl   1,661 MB   40 secs   42 secs   44 secs   37 secs
[download]

After:

               mem size   v5.26.0   v5.24.2   v5.22.4   cperl
optimized i2   1,326 MB   31 secs   32 secs   33 secs   30 secs
2 nums into 1  1,292 MB   33 secs   34 secs   35 secs   31 secs
shorter impl   1,443 MB   35 secs   36 secs   37 secs   31 secs
[download]

The optimization was made to "Check dead cells".

package Organism;

use strict;
# use warnings;

sub count {
   return scalar keys %{ shift->{Cells} };
}

# Input a list of [ x, y ] coords
sub insert_cells {
   my $cells = shift->{Cells};
   for my $r (@_) { $cells->{ pack 'i2', @{$r} } = undef }
}

# Return sorted list of cells in the Organism.
# Used for verification and testing the state of the organism.
sub get_live_cells {
   sort { $a->[0] <=> $b->[0] || $a->[1] <=> $b->[1] }
      map { [ unpack 'i2', $_ ] }
      keys %{ shift->{Cells} };
}

sub tick {
   my $self  = shift;
   my $cells = $self->{Cells};
   my ( $k1, $k2, $k3, $k4, $k5, $k6, $k7, $k8,
        $x0, $x1, $x2, $y0, $y1, $y2, %new_cells, %dead_cells );

   for my $c (keys %{ $cells }) {
      # Get the (up to 8) dead cells surrounding the cell
      ( $x0, $y0 ) = unpack 'i2', $c;
      ( $x1, $x2, $y1, $y2 ) = ( $x0 - 1, $x0 + 1, $y0 - 1, $y0 + 1 );

      my @zcells = (
         ($k1 = pack 'i2', $x1, $y1) x !(exists $cells->{$k1}),
         ($k2 = pack 'i2', $x1, $y0) x !(exists $cells->{$k2}),
         ($k3 = pack 'i2', $x1, $y2) x !(exists $cells->{$k3}),
         ($k4 = pack 'i2', $x0, $y1) x !(exists $cells->{$k4}),
         ($k5 = pack 'i2', $x0, $y2) x !(exists $cells->{$k5}),
         ($k6 = pack 'i2', $x2, $y1) x !(exists $cells->{$k6}),
         ($k7 = pack 'i2', $x2, $y0) x !(exists $cells->{$k7}),
         ($k8 = pack 'i2', $x2, $y2) x !(exists $cells->{$k8}) );

      # Check the live cell
      # Note: next line equivalent to nlive == 2 || nlive == 3
      @zcells == 5 || @zcells == 6 and $new_cells{$c} = undef;

      # Check the dead cells
      for my $z ( @zcells ) {
         $new_cells{$z} = undef if ++$dead_cells{$z} == 3;
      }
   }

   $self->{Cells} = \%new_cells;
}

sub new {
   my $class = shift;
   my %init_self = ( Cells => {} );
   bless \%init_self, $class;
}

1;
[download]

Regards, Mario