asynchron und parallel - lichtkind.de · herbert breunung u.a. heise.de lichtkind.de/vortrag...

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