http://qs321.pair.com?node_id=11115088

Mon cher ami Laurent_R recently blogged about his solution to the "extra credit" problem in the Perl Weekly Challenge #54. He showed a solution using memoizing, or caching, to reduce the number of repeated calculations made by a program.

I wondered about the strategy. Obviously calculating the sequences for numbers up to 1,000,000 without some optimization would be painfully or maybe unworkably slow. But the task looks computation-intensive, so I wanted to see whether more cycles would be more beneficial than caching.

Here is the solution presented by Laurent:

```#!/usr/bin/perl
use strict;
use warnings;
use feature qw/say/;
use Data::Dumper;
use constant MAX => 300000;

my %cache;

sub collatz_seq {
my \$input = shift;
my \$n = \$input;
my @result;
while (\$n != 1) {
if (exists \$cache{\$n}) {
push @result, @{\$cache{\$n}};
last;
} else {
my \$new_n = \$n % 2 ? 3 * \$n + 1 : \$n / 2;
push @result, \$new_n;
\$cache{\$n} = [\$new_n, @{\$cache{\$new_n}}]
if defined (\$cache{\$new_n}) and \$n < MAX;
\$n = \$new_n;
}
}
\$cache{\$input} = [@result] if \$n < MAX;
return @result;
}

my @long_seqs;
for my \$num (1..1000000) {
my @seq = (\$num, collatz_seq \$num);
push @long_seqs, [ \$num, scalar @seq] if scalar @seq > 400;
}

@long_seqs = sort { \$b->[1] <=> \$a->[1]} @long_seqs;
say  "\$_->[0]: \$_->[1]" for @long_seqs[0..19];
# say "@{\$cache{\$long_seqs[0][0]}}";

This runs on my system pretty quickly:

```real    0m22.596s
user    0m21.530s
sys    0m1.045s

Next I ran the following version using mce_map_s from MCE::Map. mce_map_s is an implementation of the parallelized map functionality provided by MCE::Map, optimized for sequences. Each worker is handed only the beginning and end of the chunk of the sequence it will process, and workers communicate amongst themselves to keep track of the overall task. When using mce_map_s, pass only the beginning and end of the sequence to process (also, optionally, the step interval and format).

```use strict; use warnings; use feature 'say';
use Data::Dumper;
use MCE::Map;

my @output = mce_map_s {
my \$input = \$_;
my \$n = \$input;

my @result = \$input;

while ( \$n != 1 ) {
\$n = \$n % 2 ? 3 * \$n + 1 : \$n / 2;
push @result, \$n;
}

return [ \$input, scalar @result ];
} 1, 1000000;

MCE::Map->finish;

@output = sort { \$b->[1] <=> \$a->[1] } @output;

say sprintf('%s : length %s', \$_->[0], \$_->[1]) for @output[0..19];

This program, with no caching, runs on my system about five times faster (I have a total of 12 cores):

```real    0m4.322s
user    0m27.992s
sys    0m0.170s

Notably, reducing the number of workers to just two still ran the program in less than half the time than Laurent's single-process memoized version. Even running with one process, with no cache, was faster. This is no doubt due to the fact MCE uses chunking by default. Even with one worker the list of one million numbers was split by MCE into chunks of 8,000.

Next, I implemented Laurent's cache strategy, but using MCE::Shared::Hash. I wasn't really surprised that the program then ran much slower than either previous version. The reason, of course, is that this task pretty much only makes use of the CPU, so while throwing more cycles at it it a huge boost, sharing data among the workers - precisely because the task is almost 100% CPU-bound - only slows them down. Modern CPUs are very fast at crunching numbers.

I was curious about how busy the cache was in this case, so I wrapped the calls to assign to and read from the hash in Laurent's program in a sub so I could count them. The wrappers look like:

```my %cache;
my \$sets = my \$gets = 0;
sub cache_has { \$gets++; exists \$cache{\$_[0]} }
sub cache_set { \$sets++; \$cache{\$_[0]} = \$_[1] }
sub cache_get { \$gets++; \$cache{\$_[0]} }
```Sets: 659,948