The stupid question is the question not asked PerlMonks

### comment on

 Need Help??

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]}}";
[download]```

This runs on my system pretty quickly:

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

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];
[download]```

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
[download]```

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]} }
[download]```

The result:

```Sets: 659,948
Gets: 16,261,635
[download]```
That's a lot of back and forth.

So the moral of the story is that while caching is often useful when you are going to make the same calculations over and over, sometimes the cost of the caching exceeds the cost of just making the calculations repeatedly.

Hope this is of interest!

Title:
Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post; it's "PerlMonks-approved HTML":

• Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
• Titles consisting of a single word are discouraged, and in most cases are disallowed outright.
• Read Where should I post X? if you're not absolutely sure you're posting in the right place.
• Please read these before you post! —
• Posts may use any of the Perl Monks Approved HTML tags:
a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
• You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)
 For: Use: & & < < > > [ [ ] ]
• Link using PerlMonks shortcuts! What shortcuts can I use for linking?
• See Writeup Formatting Tips and other pages linked from there for more info.
• Log In?
 Username: Password:

What's my password?
Create A New User
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others about the Monastery: (3)
As of 2020-10-22 06:06 GMT
Sections?
Information?
Find Nodes?
Leftovers?
Voting Booth?
My favourite web site is:

Results (225 votes). Check out past polls.

Notices?