asynchron und parallel - lichtkind.de · herbert breunung u.a. heise.de lichtkind.de/vortrag...
TRANSCRIPT
Perl 6
asynchron und parallel
Perl 6
KonzepteSchlüsselworte, Ops
Anwendung
mein Hauptprojekt ...
Herbert Breunung
ArtikelautorRedner
ModeratorProgrammierer
Herbert Breunung
u.a. heise.delichtkind.de/vortrag
de.perl.orggithub bitbucket CPAN
Herbert Breunung
u.a. heise.delichtkind.de/vortrag
de.perl.orgmodules.perl6.org
wichtige URL:
perl6.orgdocs.perl6.org
rakudo.orgmodules.perl6.org
Perl 6
6.c Christmas 2015
6.d Diwali 2018
Perl 6
use v6.c;use v6.d;
use v5.28;
Perl 6 – Hauptfunkt.
Grammatiken +
Meta-programmierung
Jonathan Worthinton
jnthn.net
Begriffsklärung
asynchronberlappendes Start Endeü
parallelgleicher Start
Beschleunigung:
asynchronoptimale Nutzung 1 Kern
parallelOpt. Nutzung 2+ Kerne
Begriffsklärung
asynchronnicht deine Entscheidung
paralleldeine Entscheidung
Konzepte:
LL: Lock Semaphor Thread Modul: Actor
HL: PromiseSupply Channel
Dieser Vortrag:
LL: Lock Semaphor Thread Modul: Actor
HL: PromiseSupply Channel Ops
High Level Konzepte:
langsamerschränkte ein
sicherdeklarativ
standardisiert
Low Level Konzepte:
goto SpeicheradresseSpeicher allokierenReferenzadressen
umbiegen
Perl 6 Threads
Thread
Klasse Thread:my @threads = do for 1.. 5 → $id { Thread.start: { say "starte $id"; sleep 1; say "Schüss $id"} }.join for @threads;
Klasse Thread:starte 1starte 2
...Schüss 2Schüss 1Schüss 3Schüss 4Schüss 5
Klasse Thread:
Thread.start: {say "start $id - $*THREAD.id"; ...}
Scheduler:for 1..10 → $i { $*SCHEDULER.cue: { say "start $i"; sleep 0.5; say "schüss $i"} }
Parallelität:
race: Reihenfolge unwichtig
hyper : Reihenfolge !
Parallelität:
say ^100000 .grep(*.is-prime) .elems;
Parallelität:
say (grep({$_.is-prime}, 0..99999) ).elems;
Parallelität:
say ^100000 .race .grep(*.is-prime) .elems;
Parallelität:
say ^100000 .race(:1024batch, :12degree) .grep(*.is-prime) .elems;
Reihenfolge !
say ^100000 .hyper(:1024batch, :12degree) .grep(*.is-prime) .elems;
Hyperops:
say (1,2,3) »+« (4,5,6);
# OUTPUT: «(5 7 9)»
Datenstrukturen:
Concurrent::Queue Concurrent::Stack Concurrent::Trie
Perl 6 Asynchron
Asynchron
Sachsenspiegel:
Die ok irst to der molen kumt, die sal erst malen
Klasse Lock:
my $l = Lock.new;$l.lock; # Tür zu$l.unlock;$l.protect: {...}; #atom.
Operator:
'ATOM SYMBOL' (U+269B)
Klasse Lock:
Verklemmung
Semaphore:
my $s = Semaphore.new;$s.acquire;$s.try_acquire;$s.release;
Semaphore:
Verklemmung
Klasse Monitor:
use OO::Monitors;
monitor Name {..} # statt
class Name {...}
Klasse Actor:
use OO::Actors;
actor Eventlog {..} # statt
class Eventlog {...}
Klasse Actor:
use OO::Actors;
actor Eventlog {...}
Methoden geben Versprechen
Promise:
my $p = Promise.start;
my $p = start {...}
Promise:
my $p = Promise.in(2);
Promise.at(now +2) .then({ say "kling" });
Promise:
$p.keep(“Ergebnis“);$p.break(“Grund“);
$p.cause;
Promise:
$p.status ~~ Kept$p.Bool if $p {..$p.result # hab Zeitawait
Sortieralgorithmus
sub parallel-merge-sort (@values, $from = 0, $elems = @values.elems){
my $divide = ( $elems / 2).ceiling; my ($left, $right) = await (start parallel-merge-sort(@v,$from,$divide), start parallel-merge-sort(@v,$f+$div, $el-$d)); merge $left, $right;}
Sortieralgorithmus
In Perl 6.d werden dabei nur soviel Threads erzeugt wie Kerne vorhanden
Promise:
$p.allof( @p );$p.anyof( @p );
$p.vow( $o );$s = $p.Supply( );
Promise:my @parsers = (start parse $to-parse, $to-search) xx 8;
Promise.allof(@parsers) .then({ $to-search.close });
Supply
Muster:Beobachter
Supply
.live True
on demand
Supply
zuhören
fordern
Supply
Absender zahlt
Channel
Absender zahlt
Empfänger zahlt
Supplier
my $sender = Supplier.new();
my $leitung = $sender.Supply;
Supplier
my $sender = Supplier.new();my $leitung = $sender.Supply;
$leitung.tap(-> $v { say "$v" });$sender.emit( 7331 );$leitung.list();
Sequence Op
put (1, 1, *+* ... *)
…
Sequence Op
put (1, 1, *+* ... *)[0..10]
1 1 2 3 5 8 13 21 34 55 89
Endlosschleife
my @fib = (1, 1, *+* ... *);my $leitung = Supply.from-list(@fib);
$leitung.tap(-> $v { say $v });
Beziehungen
Promise: $ 1 - 1
Supply: @ 1 - *
Channel: @ 1 - 1
Channel:
my $c = Channel.new();
$c.send('Nachricht'); # !blsay $c.recieve; # blockt say $c.list; # blocktsay $c.poll; # blockt nicht
Channel:
$c.send('Nachricht');say $c.recieve; say $c.close; await( @c );
Feed Operator:
<people of earth> ==> map(*.tc) ==> grep /<[PE]>/ ==> sort() ==> @result;
whenever:
for @liste → $i {…}
$var = whenever {...}
whenever:
for @liste → $i {…}
$var = whenever {...}
react:
react {…}
# wartet bis alle# Kanäle geschlossen
supply:
supply {…}
# ermöglicht ständige# Abfragen
whenever:
react { whenever {...} whenever {...}}
whenever:whenever $client.get($url) -> $response { if $response.content-type .type-and-subtype eq 'text/html' {...} QUIT {
note "$url failed: " ~ .message; } }
Danke