Praktikum Funktionale Programmierung Teil 4 ... · > -> Counter > ->...

23
1 Praktikum Funktionale Programmierung Teil 4: Nebenl¨ aufigkeit – Concurrent Mark 2 Professur f¨ ur K¨ unstliche Intelligenz und Softwaretechnologie Sommersemester 2009

Transcript of Praktikum Funktionale Programmierung Teil 4 ... · > -> Counter > ->...

1

Praktikum Funktionale ProgrammierungTeil 4: Nebenlaufigkeit – Concurrent Mark 2

Professur fur Kunstliche Intelligenz und Softwaretechnologie

Sommersemester 2009

ZeitplanTeil 4

Beenden von Threads

Zeitplan

Meilenstein 1

Teil 1: Lexen und Parsen 27. April (2 Wochen)Teil 2: Semantische Analyse und Transformation 4. Mai (1 Woche)

Meilenstein 2

Teil 3: Abstrakte Maschinen Mark 1 und Mark 2 1. Juni (4 Wochen)

Meilenstein 3

Teil 4: Nebenlaufigkeit: Concurrent Mark 2 22. Juni (3 Wochen)Teil 5: Codeerzeugung, Compiler, Interpreter und VM 6. Juli (2 Wochen)Teil 6: Verbesserungen: Garbage Collection 13. Juli (1 Woche)

Professur KIST, SoSe 2009, 8. Juni 2009 2 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Abschluss Meilenstein 2

Abschluss nachsten Montag (1. Juni), aber Pfingstmontag.Termine fur das Prasentieren:

Mittwoch (3. Juni) 9-12, 14-16

Donnerstag (4. Juni) 14-18

Freitag (5. Juni) 9-12

oder: Montag (8. Juni) nach der Praktikumsbesprechung(15.30-18)

Professur KIST, SoSe 2009, 8. Juni 2009 3 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Teil 4: Nebenlaufigkeit – Concurrent Mark 2

Professur KIST, SoSe 2009, 8. Juni 2009 4 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Auswertung von amb und por

Fur die Auswertung von

amb s t bzw.

por s t

muss man

zunachst s und t nebenlaufig auswerten

Anschließend:Fur amb:

Erstes Ergebnis wird als Gesamtresultat ubernommen

Fur por:

Ein Ergebnis ist True, dann Gesamtresultat True.

beide False, dann Gesamtresultat False.

Professur KIST, SoSe 2009, 8. Juni 2009 5 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Zustand Mark 2

(Γ, e, E, S)

Heap CoreLFPCR-Ausdruck

Umgebung Stack

Professur KIST, SoSe 2009, 8. Juni 2009 6 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Zustand Mark 2

(Γ, e, E, S)

Heap CoreLFPCR-Ausdruck

Umgebung Stack

Professur KIST, SoSe 2009, 8. Juni 2009 6 Praktikum Funktionale Programmierung, Teil 4

Thread

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Zustand Concurrent Mark 2 (Idee)

(Γ,

Thread=(Ausdruck,Umgebung,Stack)

selektierter Thread

innerer Knoten: Stack, amb/por, Ressourcen)Heap Prozessbaum

Professur KIST, SoSe 2009, 8. Juni 2009 7 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Zustandstransition

Blatt (Thread) nichtdeterministisch auswahlen

Gewahlter Thread steuert Transition

3 Arten an Transitionen:

Γt

→ Γ′t′

Γt

→ Γ′

t′

Γt

→ Γt1 t2

Professur KIST, SoSe 2009, 8. Juni 2009 8 Praktikum Funktionale Programmierung, Teil 4

Aufspaltung in 2 neue ThreadsAuswertung der amb- bzw.por-Argumente

Anderung des Teilbaums direktuber dem gewahlten Blatt(Ruckkehr von amb- oderpor-Auswertung)

Anderung des gewahltenThreads und evtl. Heaps(wie bei Mark 2)

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Zustandstransition

amb-Auswertung

`(amb s t), E, S

´→

Γ , → Γ′ ,`v, E, S

´

Γ , → Γ′ ,`v, E, S

´

Professur KIST, SoSe 2009, 8. Juni 2009 9 Praktikum Funktionale Programmierung, Teil 4

AMB,S

`v, E, []

´PT

AMB,S

`v, E, []

´PT

AMB, S

`s, E, []

´ `t, E, []

´

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Prozessbaume

data PTree a b =-- Knoten:

Node a NDVal Integer Integer (PTree a b) (PTree a b)-- Blatt:| Leaf b

wobei NDVal definiert is als

data NDVal = AMB | POR

Professur KIST, SoSe 2009, 8. Juni 2009 10 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Maschinenzustand

type CMark2Heap = Heap Integer (CoreLFPCR, M2.Mark2Environment)type CMark2PTree = PTree M2.Mark2Stack CMark2Thread

data CMark2State =CMark2State {

heap :: CMark2Heap,ptree :: CMark2PTree }

data CMark2Thread =CMark2Thread{

control :: CoreLFPCR,stack :: M2.Mark2Stack,environment :: M2.Mark2Environment }

wobei Mark 2 wiederverwendet wird

import qualified LFPC.AbsM.Mark2 as M2

Professur KIST, SoSe 2009, 8. Juni 2009 11 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Start-/ Endzustand

Startzustand

Fur einen Ausdruck e: (∅, leaf(e, ∅, []))

Aufgabe 15

Implementieren Sie im Modul LFPC.AbsM.ConcurrentMark2 dieFunktion startState :: CoreLFPCR -> CMark2State, die fur einenCoreLFPCR Ausdruck den Startzustand der Concurrent Mark 2-Maschineberechnet.

Endzustand

(Γ, leaf(v, E, [])) wobei v ein Wert ist

Professur KIST, SoSe 2009, 8. Juni 2009 12 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Transition (ohne Ressourcen) (1)

Mark 2 Transitionen

(Γ, TRJleaf(e, E, S)K) a−→ (Γ′, TRJleaf(e′, E′, S′)K)falls (Γ, e, E, S)

a−→ (Γ′, e′, E′, S′)mit einer Transition der Mark 2

Starten der amb- / por-Auswertung: Erzeugen von 2 Threads

(Γ, TRJleaf(amb s t, E, S)K)fork−amb−−−−−−−→ (Γ, TRJnode(S, amb, (leaf(s, E, [])), (leaf(t, E, [])))K)

(Γ, TRJleaf(por s t, E, S)K) fork−por−−−−−−→(Γ, TRJnode(S, por, (leaf(s, E, [])), (leaf(t, E, [])))K)

Professur KIST, SoSe 2009, 8. Juni 2009 13 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Transition (ohne Ressourcen) (2)

Beenden der amb- / por-Auswertung

(Γ, TRJnode(S, amb, leaf(v, E, [])), PTmK)choose−amb−l−−−−−−−−−−→ (Γ′, TRJleaf(v, E, S)K) , falls v ein Wert ist und nfΦ(Γ, PTm) = Γ′

(Γ, TRJnode(S, amb, PTn, leaf(v, E, []))K)choose−amb−r−−−−−−−−−−→ (Γ′, TRJleaf(v, E, S)K) , falls v ein Wert ist und nfΦ(Γ, PTn) = Γ′

(Γ, TRJnode(S, por, leaf(True, E, [])), PTmK)choose−por−true−l−−−−−−−−−−−−−→ (Γ′, TRJleaf(True, E, S)K) , falls nfΦ(Γ, PTm) = Γ′

(Γ, TRJnode(S, por, PTn, leaf(True, E, []))K)choose−por−true−r−−−−−−−−−−−−−→ (Γ′, TRJleaf(True, E, S)K) , falls nfΦ(Γ, PTn) = Γ′

(Γ, TRJnode(S, por, leaf(False, E1, []), leaf(False, E2, []))K)choose−por−false−−−−−−−−−−−−→ (Γ, TRJleaf(False, E1, [])K)

Professur KIST, SoSe 2009, 8. Juni 2009 14 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Transition (ohne Ressourcen) (3)

Weitere Blackholes

(Γ, TRJnode(S, por, leaf(v, E, [])), PTmK)blackhole4−−−−−−−→ (Γ, TRJnode(S, por, leaf(v,E , [])), PTmK)

falls v ein Wert ist, keine andere Regel anwendbar ist.

(Γ, TRJnode(S, por, PTn, leaf(v, E, []))K)blackhole5−−−−−−−→ (Γ, TRJnode(S, por, PTn, leaf(v, E, []))K)

falls v ein Wert ist, keine andere Regel anwendbar ist.

Professur KIST, SoSe 2009, 8. Juni 2009 15 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Thread-Auswahl

select(TRJ�K, leaf(s, E, S)) = (TRJ�K, leaf(s, E, S))

select(TRJ�K, node(S, ndV al, n, m, PT1, PT2)) =8<:select(TRJnode(S, ndV al, n− 1, m, J�K, PT2)K, PT1)oderselect(TRJnode(S, ndV al, n, m− 1, PT1, J�K)K, PT1)

falls m > 0 und n > 0

select(TRJ�K, node(S, ndV al, n, 0, PT1, PT2)) =select(TRJnode(S, ndV al, n− 1, 0, J�K, PT2)K, PT1)

falls n > 0

select(TRJ�K, node(S, ndV al, 0, m, PT1, PT2)) =select(TRJnode(S, ndV al, 0, m− 1, PT1, J�K)K, PT2)

falls m > 0

select(TRJ�K, node(S, ndV al, 0, 0, PT1, PT2)) =select(TRJ�K, node(S, ndV al, n, m, PT1, PT2))

wobei n und m beliebige naturliche Zahlen großer 0 sind

Professur KIST, SoSe 2009, 8. Juni 2009 16 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

IdeeProzessbaumeMaschine

Folgezustand

Aufgabe 16

Implementieren Sie im Modul LFPC.AbsM.ConcurrentMark2

die Funktion nextState mit der Signatur:

> nextState :: CMark2State

> -> RandomList

> -> Counter

> -> (CMark2State,RandomList,Counter)

Die Funktion erwartet einen Zustand der Concurrent Mark 2-Maschine, eine Liste von Zufallszahlen und einen Counter.Als Ergebnis liefert sie ein 3-Tupel bestehend aus dem Nachfolgezustand, den verbleibenden Zufallszahlen und demmodifizierten Counter.Der Typ RandomList ist im Modul LFPC.Util.Declarations gerade definiert als type RandomList = [Integer]. Siebenotigen die Zufallszahlen zum einen zum Auswahlen eines linken oder rechten Teilbaums (z.B. wenn die erste Zahlungerade ist, dann links, sonst rechts) und fur das Scheduling, zum Erhohen der Ressourcen.

die Funktion

> finalState :: CMark2State

-> RandomList

-> Counter

-> (CMark2State, RandomList, Counter)

die einen Zustand, eine Liste von Zufallszahlen und einen Counter erwartet, den Endzustand der Maschine, den neuenCounter und die nicht benutzten Zufallszahlen zuruckgibt.

die Funktion exec :: CoreLFPCR -> RandomList -> Counter -> String, die einen CoreLFPCR-Ausdruck, eine Listevon Zufallszahlen und einen Counter erhalt und zunachst den Startzustand, anschließend den Endzustand derConcurrent Mark 2-Maschine berechnet und das Ergebnis als String zuruck gibt. Wie vorher sollten Zahlen inDezimaldarstellung zuruck konvertiert werden. Hierbei ist darauf zu achten, dass erneute Berechnungen zum AusdruckenBindungen im Heap nur einmal und nicht mehrfach auswerten.

Professur KIST, SoSe 2009, 8. Juni 2009 17 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Das Problem – Ein Beispiel (falsch)

Nochmal das Problem:{}, Leaf (letrec x = True in (amb (\y -> x) x) x, {}, [])

mkBinds−−−−−−−→{p1 -> (True,{x->p1}}, Leaf ((amb (\y -> x) x) x, {x -> p1}, [])

push−−−→{p1 -> (True,{x->p1}}, Leaf ((amb (\y -> x) x) , {x->p1}, [AppRet p1])

fork(amb)−−−−−−−→{p1 -> (True,{x->p1}}, Node AMB [AppRet p1]

(Leaf ((\y -> x),{x->p1},[])

(Leaf (x, {x->p1}, []))enter−−−−→

{{}, Node AMB [AppRet p1]

(Leaf ((\y -> x),{x->p1},[])

(Leaf (True, {x->p1}, [HeapRet p1]))choose−amb−l−−−−−−−−−−−→

{{}, (Leaf ((\y -> x),{x->p1},[AppRet p1])

take−−−→ {{}, (Leaf (x,{x->p1,y->p1},[])

blackhole−−−−−−−→Professur KIST, SoSe 2009, 8. Juni 2009 18 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Das Problem – Ein Beispiel (richtig)

. . .choose−amb−l−−−−−−−−−−−→

{{p1 -> (True,{x -> p1})}, (Leaf ((\y -> x),{x->p1},[AppRet p1])

take−−−→{{p1 -> (True,{x -> p1})}, (Leaf (x,{x->p1,y->p1},[])

enter−−−−→{{}, (Leaf (True,{x->p1},[HeapRet p1])

update−−−−−→{{p1 -> (True,{x -> p1})}, (Leaf (True,{x->p1},[])

Professur KIST, SoSe 2009, 8. Juni 2009 19 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Losung: Heapeintrage zuruckschreiben

formal: Rewritingsystem

(Γ, TRJleaf(s, E, #app(p) : S)K)Φ1−−→ (Γ, TRJleaf(s x, E ∪ {x 7→ p}, S)K)

wobei x neue Variable

(Γ, TRJleaf(s, E, #heap(p) : S)K)Φ2−−→ (Γ{p 7→ (s, E)}, TRJleaf(x, {x 7→ p}, S)K)

wobei x neue Variable

(Γ, TRJleaf(s, E1, #case(alts, E2) : S)K)Φ3−−→ (Γ ∪ {p 7→ (s, E1)}, TRJleaf(case x alts, E2 ∪ {x 7→ p}, S)K)

wobei p neue Heapvariable und x neue Variable

(Γ, TRJleaf(s, E1, #seq(t, E2) : S)K)Φ4−−→ (Γ ∪ {p 7→ (x, E1)}, TRJleaf(seq x t, E2 ∪ {x 7→ p}, S)K)

wobei p neue Heapvariable und x neue Variable

(Γ, TRJnode(S, amb, m, n, leaf(tl, El, []), leaf(tr, Er, []))K)Φ5−−→ (Γ ∪ {p 7→ (tr, Er)}, TRJleaf(amb tl x, El ∪ {x 7→ p}, S)K)

wobei p neue Heapvariable und x neue Variable

(Γ, TRJnode(S, por, m, n, leaf(tl, El, []), leaf(tl, El, []))K)Φ6−−→ (Γ ∪ {p 7→ (tr, Er)}, TRJleaf(por tl x, El ∪ {x 7→ p}, S)K)

wobei p neue Heapvariable und x neue Variable

Professur KIST, SoSe 2009, 8. Juni 2009 20 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Losung: Heapeintrage zuruckschreiben

Da das Rewriting-System konvergent (terminierend und (lokal)konfluent) ist, existieren eindeutige Normalformen.

Man findet Normalform, indem man die Regeln (Reihenfolge egal)solange anwendet, bis nichts mehr geht.

Normalformen sind von der Form (Γ, leaf(e, E, [])).Wir brauchen nur den Heap Γ

Professur KIST, SoSe 2009, 8. Juni 2009 21 Praktikum Funktionale Programmierung, Teil 4

ZeitplanTeil 4

Beenden von Threads

Aufgaben

Aufgabe 17Implementieren Sie das korrekte Beenden der Threads im Modul LFPC.AbsM.ConcurrentMark2, indem Sie dieFunktion nfPhi implementieren. Hierfur mussen Sie aus dem Ersetzungssystem einen rekursiven Algorithmuskonstruieren, der die Normalform berechnet.Testen Sie anschließend Ihre Maschine mit nichtdeterministischen Operatoren.

Aufgabe 18Implementieren Sie im Modul LFPC.Run eine Funktion runCMark2 :: Int -> String -> String die eine Zahl

erwartet (zum Initialisieren des Zufallsgenerators) und ein LFP+C-Programm und dieses lext, parst, semantischanalysiert und auf der Concurrent Mark 2-Maschine ausfuhrt und das Ergebnis der Ausfuhrung als Stringzuruckgibt.

Professur KIST, SoSe 2009, 8. Juni 2009 22 Praktikum Funktionale Programmierung, Teil 4