DerCHF-KalkülalsModellfürConcurrentHaskell NebenläufigenProgrammierung DerCHF-Kalkül DerCHF-Kalkül:Syntax Übersicht

(1)

Prinzipien, Modelle und Algorithmen der Nebenl¨aufigen Programmierung

Wintersemester 2019/20

Der CHF-Kalk¨ul als Modell f¨ur Concurrent Haskell

Prof. Dr. David Sabel

LFE Theoretische Informatik

Letzte ¨Anderung der Folien: 6. Februar 2020

Ubersicht¨

1 Der CHF-Kalk¨ul Syntax Typisierung Semantik Fairness Gleichheit

TCS | 14 CHF-Kalk¨ul | WS 2019/20 2/36 Der CHF-Kalk¨ul

Der CHF-Kalk¨ul

CHF = Concurrent Haskell erweitert um (implizite) Futures Shared Memory Modell

Speicher vorhanden durch MVars

Futures = Nebenl¨aufige Threads mit R¨uckgabewert Wie in Haskell: Seiteneffekte durch IO-Monade

Der CHF-Kalk¨ul: Syntax

Zweistufige Syntax: Oben Prozesskomponenten, unten (funktionale) Ausdr¨ucke

ProzesseP ∈Proc:

P, P_i ∈Proc ::= P₁||P₂ parallele Komposition

| νx.P Namensbeschr¨ankung

| x⇐e nebenl. Thread (Futurex)

| x=e globale Bindung

| xme gef¨ullte MVar

| xm− leere MVar Dabei:x Variable,eAusdruck

Ein Spezialthread m¨oglichx⇐^main==ederMain-Thread

(2)

Datenkonstruktoren

Es gibt Datenkonstruktoren c_{T ,i}

T ist der zugeh¨orige Typkontruktor (z.B. Bool, List, etc.) Pro Typ gibt es Konstruktorenc_T,1, . . . ,c_{T ,|T}_| (z.B. True, False)

Konstruktoren haben eine festeStelligkeit ar(c_{T ,i})∈IN₀ Konstruktoren d¨urfen nurges¨attigtauftreten:

(c_{T ,i} e₁ . . . e_ar(c

T ,i))

Annahme: Es gibt Typ() mit nullstelligem Konstruktor()

Ausdr¨ucke

Funktionale Ausdr¨ucke

e, e_i ∈Exp::=x Variable

| me monad. Ausdruck

| λx.e Abstraktion

| (e₁ e₂) Anwendung

| c e₁. . . e_ar(c) Konstruktoranw.

| seqe₁ e₂ seq-Ausdruck

| letrec x₁=e₁, . . . , x_n=e_n ine letrec-Ausdruck

| case_T eof (c_{T ,1} x₁. . . x_ar(c_{T ,1}₎ →e₁) case-Ausdruck . . .

(c_T,|T_| x₁. . . x_ar(c

T ,|T|)→e_|T_|) Monadische Ausdr¨ucke

me∈MExp::=returne|e₁>>=e₂ |futuree

|takeMVare|newMVare|putMVare₁e₂

Nebenbedingungen

case_T eof

case-Alternative

z }| {

(c_T,1 x₁. . . x_ar(c

T ,1)

| {z }

Pattern

→e₁)

. . .

(c_T,|T_| x₁. . . x_ar(c

T ,|T|)→e_|T_|) Nur Variablen im Pattern erlaubt

Variablen m¨ussen paarweise verschieden sein.

Proc_T,i genau eine Alternative

letrec x₁ =e₁

| {z }

letrec-Bindung

, . . . x_n=e_n in e

|{z}

in-Ausdruck

Bindungsbereich vonx_i: Alle e_i und e Allex_i m¨ussen paarweise verschieden sein.

Wohlgeformtheit, Strukturelle Kongruenz

Eingef¨uhrte Variablen: der Name eines Threads, der Name einer MVar, die linke Seite einer Bindung

Ein Prozess ist wohlgeformtgdw. alle eingef¨uhrten Variablen paarweise verschieden sind und es maximal einen Main-Thread gibt.

Strukturelle Kongruenz

≡ist die kleineste Kongruenz auf Prozessen, die die Regeln erf¨ullt:

P₁||P₂ ≡ P₂||P₁ P₁||(P₂||P₃) ≡ (P₁||P₂)||P₃

(νx.P₁)||P₂ ≡ νx.(P₁||P₂), fallsx6∈FV(P₂) νx₁.νx₂.P ≡ νx₂.νx₁.P

P₁ ≡ P₂, fallsP₁ undP₂ α-¨aquivalente (P₁ =_α P₂)

(3)

Typisierung

CHF ist monomorphtypisiert

τ, τ_i ∈Typ::=IOτ |(T τ₁. . . τ_ar(T₎) |MVarτ |τ₁→τ₂ Konstruktoren werden wie polymorph behandelt:Cons::List Bool,Cons :: List (List Bool)etc.

Monadische Operatoren werden ebenfalls mit mehreren Typen verwendet.

Annahme: Variablen xhaben einen eingebauten Typ Γ(x)∈Typ

Γ`P ::wt gdw. ProzessP ist wohlgetypt

Γ`e::τ gdw. Ausdruckeist wohlgetypt mit Typτ.

Typisierung (2)

Einige Typisierungsregeln Γ`P₁ ::wt,Γ`P₂ ::wt

Γ`P₁||P₂::wt

Γ`P ::wt Γ`νx.P ::wt

Γ`x::τ,Γ`e::IO τ Γ`x⇐e::wt

Γ`x::τ,Γ`e::τ Γ`x=e::wt

Γ`x::MVar τ,Γ`e::τ Γ`xme::wt

Γ`x::MVarτ Γ`xm−::wt

Γ`e::τ Γ`returne::IOτ

Γè₁ ::IOτ₁,Γè₂::τ₁→IO τ₂ Γè₁>>=e₂::IOτ₂

Γ`e::IO τ Γ`futuree::IOτ

Γ`e::MVar τ Γ`takeMVare::IOτ

Γ`e₁ ::MVar τ,Γ`e₂ ::τ Γ`putMVare₁ e₂::IO()

Γ`e::τ

Γ`newMVare::IO(MVar τ)

Typisierung: Beispiele

Γ(x) =τ

Γ`x::τ,Γ(x) =τ Γ`x::τ Γ`(λx.x) ::τ →τ

Γ(x) =τ Γ`x::τ,

Γ(x) =τ

Γ`x::τ,Γ(x) =τ Γ`x::τ (x x) ::?

λx.(x x) ::τ →?

Γ`e1::τ1→τ2, Γ`e2::τ1

Γ`(e1e2) ::τ2

id=λx.x||y=idTrue ||z=idNil id=λx.x

| {z }

τ→τ

|

|y= id

Bool→Bool|{z}

True ||z= id

|{z}

List τ→List τ

Nil

id=λx.x

| {z }

Bool→Bool

|

|id⁰=λx⁰.x⁰

| {z }

List τ→List τ

|

|y= id

Bool→Bool|{z}

True ||z= id⁰

|{z}

Listτ→List τ

Nil

Operationale Semantik: Kontexte

Prozesskontexte:

D∈PC::= [·]|D||P |P||D|νx.D Monadische Kontexte:

M∈MC::= [·]|M>>=e Evaluations- und Forcingkontexte

(4)

Operationale Semantik: LC-Kontexte

L∈LC::=x⇐M[F]

|x⇐M[F[x_n]]||x_n=En[x_n−1]||. . .||x₂ =E2[x₁]||x₁=E1

wobei E2, . . .En nicht der leere Kontext sind.

Lb∈LCd::=x⇐M[F]

|x⇐M[F[x_n]]||x_n=En[x_n−1]||. . .||x₂ =E2[x₁]||x₁=E1

wobei E1,E2, . . .En nicht der leere Kontext sind.

Standardreduktion −→^CHF

Monadische Berechnungen:

(CHF,lunit) y⇐M[returne₁>>= e₂]−−→^CHF y⇐M[e₂ e₁]

(CHF,tmvar)y⇐M[takeMVarx]||xme−−→^CHF y⇐M[returne]||xm− (CHF,pmvar)y⇐M[putMVarx e]||xm−−−→^CHF y⇐M[return ()]||xme (CHF,nmvar)y⇐M[newMVare]−−→^CHF νx.(y⇐M[returnx]||xme) (CHF,fork) y⇐M[futuree]−−→^CHF νz.(y⇐M[return z]||z⇐e)

wobeiz ein neuer Name ist und der erzeugte Thread kein Main-Thread ist

(CHF,unIO) y⇐return e−−→^CHF y=e,

wenn Thread y kein Main-Thread ist

Standardreduktion −→^CHF (2)

Funktionale Auswertung:

(CHF,cp) Lb[x]||x=v−−→^CHF bL[v]||x=v,

fallsv eine Abstraktion oder eine Variable ist (CHF,cpcx) Lb[x]||x=c e₁. . . e_n,

−−→CHF νy₁, . . . y_n.(bL[cy₁. . .y_n]||x=c y₁. . .y_n||y₁=e₁||. . .||y_n=e_n) fallsc ein Konstruktor, oder ein monadischer Operator ist (CHF,mkbinds)L[letrecx₁ =e₁, . . . , x_n=e_n in e]

−−→CHF νx₁, . . . , x_n.(L[e]||x₁ =e₁||. . .||x_n=e_n)

(CHF,lbeta)L[((λx.e₁)e₂)]−−→^CHF νx.(L[e₁]||x=e₂)

(CHF,case) L[case_T (ce₁ . . . e_n) of . . .(cy₁ . . . y_n→e). . .]

−−→CHF νy₁, . . . , y_n.(L[e]||y₁ =e₁||. . .||y_n=e_n]) (CHF,seq) L[(seqve)]−−→^CHF L[e]

wennv ein funktionaler Wert ist

Standardreduktion: Abschluss

P₁≡D[P₁⁰],P₂≡D[P₂⁰]undP₁⁰ −−→^CHF P₂⁰ P₁−−→^CHF P₂

(5)

Erfolgreiche Prozesse

Definition

Ein wohlgeformter Prozess P ist genau dann erfolgreich, wenn er von der Formνx₁, . . . , x_n.x⇐^main==return e||P⁰ ist.

CHF,+

−−−→bezeichnet die transitive H¨ulle von−−→^CHF (eine oder mehr Reduktionen)

CHF,∗

−−−→bezeichnet die reflexiv-transitive H¨ulle (null oder mehr Reduktionen)

May- und Should-Konvergenz

Definition May-Konvergenz:

P↓_CHF g.d.w. ∃P⁰:P −−−→^CHF^,∗ P⁰ undP⁰ ist erfolgreich Should-Konvergenz:

P⇓_CHF g.d.w. ∀P⁰ :P −−−→^CHF^,∗ P⁰ =⇒ P⁰↓_CHF Must-Konvergenz:

P should-konvergent

und es gibt keine unendlich lange Reduktion vonP aus

Should-Konvergenz 6= Must-Konvergenz

Beispiel mit syntaktischem Zucker

x⇐^main==do future(loopP utTrue)Thread, der wiederh.Truein MVarxschreibt future(loopP utFalse)Thread, der wiederh.Falsein MVarxschreibt loop

|

|loop=do takeMVarx1x Lesen w ←takeMVarx1x Lesen

ifwwenn True, dann terminiere, sonst von vorne then return True

elseloop

|

|loopP ut=λz.do putMVar x z loopP ut z

|

|xm−

Prozess ist should-konvergent, aber nicht must-konvergent

May- und Must-Divergenz

Must-Divergenz: P⇑_CHF gdw.¬P↓_CHF May-Divergenz: P↑_CHF gdw. ¬P⇓_CHF Satz

F¨ur alle Prozesse P gilt:P↑_CHF ⇐⇒ ∃P⁰ :P −−−→^CHF^,∗ P⁰∧P⁰⇑_CHF

(6)

Kontextuelle Gleichheit

Kontextuelle Approximation:

P₁≤_CHF P₂ gdw.P₁≤_↓_CHF P₂ undP₁≤_⇓_CHF P₂, wobei P₁≤_↓_CHF P₂ gdw.∀D∈PC:D[P₁]↓_CHF =⇒ D[P₂]↓_CHF P₁≤_⇓_CHF P₂ gdw.∀D∈PC:D[P₁]⇓_CHF =⇒ D[P₂]⇓_CHF Kontextuelle Gleichheit∼_CHF auf Prozessen:

P₁ ∼_CHF P₂ gdw.P₁≤_CHF P₂ und P₂ ≤_CHF P₁

May-Konvergenz alleine reicht nicht

P1:=νz.(z⇐^main==return True) P2:=νx, z, y1, y2, loop.

(z⇐^main==takeMVarx>>=λw.caseBoolw(True→return True) (False→loop)

|

|loop=loop||y1⇐putMVarxFalse ||y2⇐putMVarxTrue ||xm−)

D[P₁]ist f¨ur alleD direkt erfolgreich F¨ur D[P₂]kann man zeigen:

D[P2]

CHF,∗

yy

CHF,∗

&&

D⁰[z⇐^main==return True] D⁰⁰[z⇐^main==loop||loop=loop]

Daher gilt:

F¨ur alle D∈PC:D[P₁]↓_CHF ⇐⇒ D[P₂]↓_CHF Aber:P₁⇓_CHF w¨ahrendP₂↑_CHF

Should-Konvergenz alleine reicht nicht

P1 :=νz, loop.(z⇐^main==loop)||loop=loop) P2 :=νx, z, y1, y2, loop.

(z⇐^main==takeMVarx>>=λw.caseBool w(True→return True) (False→loop)

|

|loop=loop||y1⇐putMVarxFalse ||y2⇐putMVarxTrue ||xm−)

D[P₁]ist f¨ur alleDmust-divergent F¨urD[P₂]kann man zeigen:

D[P2]

CHF,∗

yy

CHF,∗

&&

D⁰[z⇐^main==return True] D⁰⁰[z⇐^main==loop||loop=loop]

Daher gilt:

F¨ur alleD∈PC:D[P₁]⇓_CHF ⇐⇒ D[P₂]⇓_CHF Aber:P₁⇑_CHF w¨ahrendP₂↓_CHF

Fairness

Die Reduktion−−→^CHF beachtet keine Fairness.

Beispiel:

x⇐^main==takeMVarz||zmTrue ||y⇐loop||loop=loop

CHF,cp

−−−→ x⇐^main==takeMVarz||zmTrue ||y⇐loop||loop=loop

CHF,cp

−−−→ . . .

(7)

Fairness (2)

Ausführbarer Thread: Für einen Prozess P ≡D[x⇐e]ist der Thread x ausführbar, wenn es eine ReduktionP −−→^CHF P⁰ gibt, die entweder innerhalb des Ausdrucksereduziert, oder eine Reduktion ausführt, an der Threadx beteiligt ist (z.B. eine MVar liest oder schreibt, oder in ewird der Wert einer Bindung kopiert).

Definition

F¨ur einen ProzessP ist die Reduktionsfolge

S =P −−→^CHF P₁−−→^CHF P₂. . .unfair, wenn S einen unendlich langen Suffix S⁰ hat, in dem ein Threadx unendlich oft ausf¨uhrbar ist, aber niemals reduziert wird. Eine Reduktionsfolge ist fair, wenn sie nicht unfair ist.

Fairness (3)

Faire May-KonvergenzP↓_CHF,f und Faire Should-KonvergenzP⇓_CHF_,f Wie May-Konvergenz und Should-Konvergenz, aber nur faire

Reduktionsfolgen sind erlaubt.

Satz

↓_CHF = ↓_CHF,f und ⇓_CHF = ⇓_CHF_,f Beweis: Siehe Skript

Vorteil: Wir brauchen uns um die Fairness nicht zu k¨ummern Theorem

Kontextuelle ¨Aquivalenz inCHF bleibt unver¨andert, wenn unfaire Reduktionssequenzen verboten sind.

Resultat giltnichtf¨ur die Must-Konvergenz!

Programmtransformationen

EineProgrammtransformation T ist eine bin¨are Relation auf Prozessen

T istkorrekt, gdw. f¨ur alleP, P⁰:P −→^T P⁰ =⇒ P ∼_CHF P⁰ Korrektheitwiderlegen ist eher einfach, daein Kontext als Gegenbeispiel gen¨ugt

Korrektheitbeweisen ist eher schwierig, daalleKontexte betrachtet werden m¨ussen

Satz

Der Nachweis und die Widerlegung der Korrektheit einer Programmtransformation ist unentscheidbar.

Beweis: Reduktion des Halteproblems: Die Aussage (P 6∼_CHF x⇐^main==letrec y=y iny)entspricht dem Halteproblem

Ungleichheit - Beispiel

P₁:=x⇐return True P₂:=x⇐return False

D:= [·]||y⇐^main==case_Bool x

(True →returnTrue)

(False→letrecw=win w) D[P₁]↓_CHF aber D[P₂]⇑_CHF.

DaherP₁6∼_CHF P₂

(8)

Einige korrekte Programmtransformationen

Satz

Die Reduktionen(CHF, lunit),(CHF, nmvar),(CHF, f ork), (CHF, unIO),(CHF, mkbinds) sind korrekte

Programmtransformationen.

Beweis:

Sei P₁⁰ −→^a P₂⁰ wobeiawie im Satz undP₁≡D[P₁⁰]und P₂ ≡D[P₂⁰] Wir m¨ussen vier Implikationen zeigen:

(1) P₁↓_CHF =⇒ P₂↓_CHF (2) P₂↓_CHF =⇒ P₁↓_CHF (3) P₁⇓_CHF =⇒ P₂⇓_CHF (4) P₂⇓_CHF =⇒ P₁⇓_CHF

Einige korrekte Programmtransformationen

Vor¨uberlegungen:

Wenn P₁ −→^a P₂ und P₁ ist erfolgreich, dann muss auchP₂ erfolgreich sein, da die −→-Transformation nicht im main-Thread^a reduzieren kann.

Wenn P₁ −→^a P₂, dann auchP₁−−→^CHF P₂, da die−→-Transformation^a auch eine Standardreduktion ist.

Untersuche P₀←−−^CHF P₁ −→^a P₂ (alle F¨alle):

Man stellt fest:

P₁

CHF

a //P₂

CHF

P₀ _a ^//P₃

Einige korrekte Programmtransformationen (2)

(1) Zeige P₁↓_CHF =⇒ P₂↓_CHF:

Da P₁↓_CHF, gibt es P₁ −−→^CHF P_1,1 −−→^CHF . . .−−→^CHF P_1,n mitP_1,n erfolgreich.

Induktion ¨ubern

n= 0:P₁ ist erfolgreich. Dann muss auchP₂ erfolgreich sein.

Aussage gilt.

Induktionsschritt:

P₁

CHF

a //P₂

CHF

P_1,1 _a ^//

CHF,∗

P_2,1

Induktionshypothese

OOOO

P_1,n P_2,n⁰

(2) Zeige P₂↓_CHF =⇒ P₁↓_CHF:

Gilt sofort, da die Transformation P₁−→^a P₂ auch eine Standardreduktion ist:

Jede konvergente Reduktionsfolge fürP₂ kann durchP₁−→â P₂ verlängert werden zu einer konvergenten Reduktionsfolge für P₁.

(3) Zeige P₁⇓_CHF =⇒ P₂⇓_CHF:

¨aquivalente Aussage P₂↑_CHF =⇒ P₁↑_CHF

Offensichtlich, da wiederum jede divergierende Folge fürP₂ durchP₁−→â P₂ zu eine divergierenden Folge fürP₁ verlängert werden kann.

(9)

(4) Zeige P₂⇓_CHF =⇒ P₁⇓_CHF:

¨

aquivalente AussageP₁↑_CHF =⇒ P₂↑_CHF: P₁ −−→^CHF P_1,1 −−→^CHF . . .−−→^CHF P_1,n wobeiP_1,n⇑_CHF Induktion ¨ubern

Induktionsbasis:P₁⇑_CHF =⇒ P₂⇑_CHF: Das folgt aus (2) des Beweises!

Indukionsschritt:

P₁

CHF

a //P₂

CHF

P_1,1 _a ^//

CHF,∗

P_2,1

Induktionshypothese

OOOO

P_1,n P_2,n⁰

Gleichheit auf Ausdr¨ucken

Definition

Kontextuelle Approximation ≤_CHF undkontextuelle Gleichheit

∼_CHF f¨ur gleich getypteAusdr¨ucke ist in CHF definiert also:

≤_CHF:=≤_↓_CHF ∩ ≤_⇓_CHF und ∼_CHF:=≤_CHF∩ ≥_CHF, wobei f¨ur Ausdr¨ucke e₁, e₂ vom Typ τ:

e₁ ≤_↓_CHF e₂ gdw. ∀C[·^τ]∈CC:C[e₁]↓_CHF =⇒ C[e₂]↓_CHF e₁ ≤_⇓,CHF e₂ gdw. ∀C[·^τ]∈CC:C[e₁]⇓_CHF =⇒ C[e₂]⇓_CHF

Monadische Gesetze

Satz

In CHF gelten f¨ur alle (korrekt getypten) Ausdr¨ucke e₁, e₂, e₃ die folgenden Gleichheiten:

returne₁ >>= e₂ ∼_CHF e₂ e₁ e₁ >>= λx.returnx ∼_CHF e₁

e₁ >>= (λx.(e₂ x >>= e₃)) ∼_CHF (e₁ >>= e₂) >>= e₃

Weitere Eigenschaften von CHF

Call-by-name Auswertung ist ¨aquivalent zu call-by-need Auswertung

Es wurden noch weitere Programmtransformationen als korrekt bewiesen

CHF erweitert die pure funktionale Teilsprache konservativ:

Alle Gleichheiten die in der puren funktionalen Sprache gelten, gelten auch in CHF

Lazy Futures verletzen die Konservativit¨at!