Übersicht. Nebenläufige Programmierung: Praxis und Semantik. Nebenläufige Programmierung in Haskell (2) Design

Transkript

1 Übersicht Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Nebenläufige Programmierung in Haskell (2) PD Dr. David Sabel 1 Software Transactional Memory Übersicht Logging Beispiele T. kombinieren Philosophen 2 WS 2013/14 Stand der Folien: 28. Januar 2014 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 2/30 Software Transactional Memory in Haskell Design in Haskell von Tim Harris und Simon L. Peyton Jones 2005 eingeführt Implementiert in der Bibliothek Control.Concurrent. Erstes Papier, dass retry und orelse einführt. Trennung von Operationen auf Transaktionsvariablen und normalem IO mithilfe des Typsystems Wie IO-Monade gibt es eine -Monade Transaktionen sind vom Typ a atomically :: a -> IO a überführt eine -Aktion in eine IO-Operation Semantik: Führt die Transaktion atomar aus. Beachte: Es gibt keine Umkehrung vom Typ IO a -> a! Halbwahrheit: unsafeioto :: IO a -> a Da eine Monade ist, kann die do-notation und auch >>=, >> und return verwendet werden. D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 3/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 4/30

2 Transaktionsvariablen TVar Transaktionen data TVar a =... newtvar :: a -> (TVar a) Erzeugt eine neue TVar mit Inhalt readtvar :: TVar a -> a Liest den den momentanen Wert einer TVar atomically ( do... Zugriffe auf TVar s... und... pure funktionale Berechnungen writetvar :: TVar a -> a -> () Schreibt einen neuen Wert in die TVar... aber kein IO! newtvario :: TVar a -> a -> IO (TVar a) Erzeugen einer TVar in der IO Monade ) D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 5/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 6/30 retry Konflikterkennung: Lokales Logging saldo :: TVar Int 785 retry :: a Bricht die Transaktion ab und startet sie neu Implementierung: Neustart erst dann, wenn sich die Werte von TVars geändert haben Damit wird implizit blockiert! Thread 1 atomically ( do local <- readtvar saldo writetvar saldo (local + 1) ) TVar gelesen geschrieben saldo 7 8 Transaction log Thread 2 atomically ( do local <- readtvar saldo writetvar saldo (local - 3) ) TVar gelesen geschrieben saldo Transaction log Abort & Restart D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 7/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 8/30

3 Beispiel: Binäre Semaphore Beispiel: Unbounded Buffer type Semaphore = TVar Bool newsem :: Bool -> IO Semaphore newsem k = newtvario k -- k True/False wait :: Semaphore -> () wait sem = do b <- readtvar sem if b then writetvar sem False else retry signal :: Semaphore -> () signal sem = writetvar sem True type Buffer a = TVar [a] newbuffer :: IO (Buffer a) newbuffer = newtvario [] put :: Buffer a -> a -> () put buffer item = do ls <- readtvar buffer writetvar buffer (ls ++ [item]) get :: Buffer a -> a get buffer = do ls <- readtvar buffer case ls of [] -> retry (item:rest) -> do writetvar buffer rest return item D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 9/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 10/30 MVar innerhalb von implementieren MVar innerhalb von implementieren(2) takemvar-operation: type MVar a = TVar (Maybe a) MVar erzeugen: newemptymvar :: (MVar a) newemptymvar = newtvar Nothing takemvar :: MVar a -> a takemvar mv = do v <- readtvar mv case v of Nothing -> retry Just val -> do writetvar mv Nothing return val D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 11/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 12/30

4 MVar innerhalb von implementieren(3) Transaktionen kombinieren putmvar-operation: putmvar :: MVar a -> a -> () putmvar mv val = do v <- readtvar mv case v of Nothing -> writetvar mv (Just val) Just val -> retry >>=, >>, do erstellen aus Transaktionen zusammengesetzte Sequenzen. Beispiel: swapmvar :: MVar a -> b -> a swapmvar mv val = do res <- takemvar mv putmvar val return res swapmvar wird atomar ausgeführt, da es eine Transaktion ist. D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 13/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 14/30 Transaktionen kombinieren: Auswahl Nochmal zur MVar-Implementierung orelse :: a -> a -> a Kombiniert zwei Transaktion zu einer Wenn die erste Transaktion erfolgreich ist, dann auch die kombinierte Wenn die erste Transaktion ein retry durchführt, dann wird die zweite Transaktion durchgeführt. Wenn beide Transaktionen ein retry durchführen, so wird die gesamte Transaktion neu gestartet. Nichtblockierendes putmvar tryputmvar :: MVar a -> a -> Bool tryputmvar mv val = ( do putmvar mv val return True ) orelse (return False) D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 15/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 16/30

5 orelse erweitern Speisende Philosophen in Aufbauend auf dem binären orelse kann man problemlos neue Kombinatoren definieren. merge :: [ a] -> a merge transactions = foldl1 orelse transactions foldl1 op [x] = x foldl1 op (x:xs) = x op (foldl e op xs) merge [t1,...,tn] ergibt (t1 orelse (t2 orelse (t3 orelse... ())) Die erste erfolgreich durchgeführte Transaktion bestimmt das Ergebnis. von Josef Svenningsson simulation n = do forks <- sequence (replicate n (newsem True)) outputbuffer <- newbuffer sequence_ [forkio (philosoph i outputbuffer (forks!!i) (forks!!((i+1) mod n))) i <- [0..n-1]] output outputbuffer output buffer = do str <- atomically $ get buffer putstrln str output buffer D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 17/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 18/30 Speisende Philosophen in (2) Eigenschaften von Haskells philosoph :: Int->Buffer String->Semaphore->Semaphore->IO () philosoph n out fork1 fork2 = do atomically $ put out ("Philosoph " ++ show n ++ " denkt.") atomically $ do wait fork1 wait fork2 atomically $ put out ("Philosoph " ++ show n ++ " isst.") atomically $ do signal fork1 signal fork2 philosoph n out fork1 fork2 Isolation: Strong (kein Zugriff auf Transaktionsvariablen außerhalb von Transaktionen) Granularität: Wortbasiert Update: Verzögert (Neue Werte werden ins Log geschrieben, erst beim commit in den Speicher) Concurrency Control: optimistisch (meint keine Locks auf die Speicherplätze) Synchronisation: Blockierend Conflict Detection: Late (erst beim commit) Nested Transaction: Nein (durch Typsystem verhindert) D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 19/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 20/30

6 (2) Ideen bei : Werte Ausdrücke parallel aus In der reinen funktionalen Sprache Nicht in der IO-Monade Richtig, wenn der Wert der Ausdrücke sowieso gebraucht wird In der Bibliothek Control.Parallel: par :: a -> b -> b pseq :: a -> b -> b par erwartet zwei Argumente (par a b) Zeigt dem Laufzeitsystem an: Während b ausgewertet wird, darf a parallel ausgewertet werden Semantik: par a b = b! Laufzeitsystem darf a auswerten, muss aber nicht. Laufzeitsystem legt keinen Thread für a an, sondern einen Spark Sparks werden in eine FIFO-Queue abgelegt. Wenn ein Prozessor ungenutzt ist, wird nächster Spark dort abgearbeitet Ähnlichkeiten zu lazy futures D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 21/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 22/30 Parallelisieren Parallelisieren Beispiel let x = fib 100; y=fak 35 in par x (y+x) Compiler darf die Auswertung umstellen: (x+y) statt (y+x) Keine Parallelisierung! Lösung: pseq a b: Werte erst a aus, danach b let x = fib 100; y=fak 35 in par x (pseq y (y+x)) Beispiel let x = fib 100; y=fak 35 in par x (y+x) Compiler darf die Auswertung umstellen: (x+y) statt (y+x) Keine Parallelisierung! Lösung: pseq a b: Werte erst a aus, danach b let x = fib 100; y=fak 35 in par x (pseq y (y+x)) D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 23/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 24/30

7 Fibonacci-Zahlen berechnen Verzögerte Auswertung import Control.Parallel nfib :: Int -> Int nfib n n <= 1 = 1 otherwise = par n1 (pseq n2 (n1 + n2 + 1)) where n1 = nfib (n-1) n2 = nfib (n-2) Beachte: Ohne pseq wird nicht genügend parallelisiert: Beispiel Die verzögerte Auswertung führt oft dazu, dass weniger parallel berechnet wird, als der Programmierer annimmt. let x = map (+1) [ ] in par x s map (+1) [ ] wird ausgewertet zu (1+1):(map (+1) [ ] aber nicht weiter! Auswertung nur bis zur schwachen Kopfnormalform (WHNF)! D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 25/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 26/30 Strategien Komplexere Strategien type Strategy a = a -> () class NFData a where rnf :: Strategy a Strategie rnone: keine Auswertung rnone :: Strategy a rnone = () Strategie rwhnf: Auswertung bis zur WHNF: rwhnf :: Strategy a rwhnf a = pseq a () instance NFData a => NFData [a] where rnf [] = () rnf (x:xs) = rnf x pseq rnf xs Anwenden einer Strategie: using :: a -> Strategy a -> a using x s = (s x) pseq x D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 27/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 28/30

8 Beispiel: Quicksort Datenorientierter Parallelismus quicksort [] = [] quicksort (x:xs) = low ++ (x:high) using strategy where low = quicksort [y y <- xs, y < x] high = quicksort [y y <- xs, y >= x] strategy result = (rnf low) par (rnf high) par (rnf result) Strategie parallel auf eine Liste anwenden: parlist :: Strategy a -> Strategy [a] parlist strat [] = () parlist strat (x:xs) = strat x par (parlist strat xs) Paralleles map parmap :: Strategy b -> (a -> b) -> [a] -> [b] parmap strat f xs = map f xs using parlist strat D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 29/30 D. Sabel TIDS WS 2013/14 Nebenläufige Programmierung in Haskell 30/30