There Is More Than One Way At The Same Time
The Perl 6 Rosattacode section for parallel calculations is terribly outdated and missing all the goodies that where added or fixed in the last few weeks. With this post I would like to propose an updated version for Rosettacode. If you believe that I missed something feel free to comment below. Please keep in mind that Rosettacode is for showing off, not for being comprehensive.
use v6.d.PREVIEW;
Perl 6 provides parallel execution of code via threads. There are low level custructs that start a thread or safely pause execution.
my $t1 = Thread.start({ say [+] 1..10_000_000 }); my $t2 = Thread.start({ say [*] 1..10_000 }); $t1.finish; $t2.finish; my $l = Lock.new; $l.lock; $t1 = Thread.start: { $l.lock; say 'got the lock'; $l.unlock }; sleep 2; $l.unlock; $t1.finish;
When processing lists, one can use a highlevel Iterator
created by the methods hyper
and race
. The latter may return values out of order. Those Iterator
s will distribute the elements of the list to worker threads that are in turn assigned to OS level threads by Rakudos ThreadPoolScheduler
. The whole construct will block until the last element is processed.
my @values = 1..100; sub postfix:<!> (Int $n) { [*] 1..$n } say [+] @values.hyper.map( -> $i { print '.' if $i %% 100; $i!.chars });
For for
-lovers there are the race for
and hyper for
keyword for distributing work over threads in the same way as their respective methods forms.
race for 1..100 { say .Str; # There be out of order dragons! } my @a = do hyper for 1..100 { .Int! # Here be thread dragons! } say [+] @a;
Perl 6 sports constructs that follow the reactive programming model. One can spin up many worker threads and use threadsafe Channel
s or Supply
s to move values from one thread to another. A react
-block can combine those streams of values, process them and react to conditions like cleaning up after a worker thread is done producing values or dealing with errors. The latter is done by bottling up Exception
-objects into Failure
-objects that keep track of where the error first occured and where it was used instead of a proper value.
my \pipe = Supplier::Preserving.new; start { for $*HOME { pipe.emit: .IO if .f & .ends-with('.txt'); say „Looking in ⟨{.Str}⟩ for files that end in ".txt"“ if .IO.d; .IO.dir()».&?BLOCK when .IO.d; CATCH { default { note .^name, ': ', .Str; pipe.emit: Failure.new(.item); } } } pipe.done; } react { whenever pipe.Supply { say „Checking ⟨{.Str}⟩ for "Rosetta".“; say „I found Rosetta in ⟨{.Str}⟩“ if try .open.slurp.contains('Rosetta'); LAST { say ‚Done looking for files.‘; done; } CATCH { default { note .^name, ': ', .Str; } } } whenever Promise.in(60*10) { say „I gave up to find Rosetta after 10 minutes.“; pipe.done; done; } }
Many build-in objects will return a Supply
or a Promise
. The latter will return a single value or just convey an event like a timeout. In the example above we used a Promise
in that fashion. Below we shell out to find
and process its output line by line. This could be used in a react
block if there are many different types of events to process. Here we just tap
into a stream of values and process them one by one. Since we don’t got a react
block to provide a blocking event loop, we wait for find
to finish with await
and process it’s exitcode. Anything inside the block given to .tap
will run in its own thread.
my $find = Proc::Async.new('find', $*HOME, '-iname', '*.txt'); $find.stdout.lines.tap: { say „Looking for "Rosetta" in ⟨$_⟩“; say „Found "Rosetta" in ⟨$_⟩“ if try .open.slurp.contains('Rosetta'); }; await $find.start.then: { say „find finished with exitcode: “, .result.exitcode; };
Having operators process values in parallel via threads or vector units is yet to be done. Both hyper operators and Junction
s are candidates for autothreading. If you use them today please keep in mind side effects may provide foot guns in the future.
-
October 23, 2017 at 23:372017.43 Hyper lands, racing… | Weekly changes in and around Perl 6