HAL Id: hal-00909497
https://hal.inria.fr/hal-00909497
Submitted on 26 Nov 2013
HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci- entific research documents, whether they are pub- lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.
L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.
Haskell : De nouvelles voies pour le parallélisme
Laurent Pierron
To cite this version:
Laurent Pierron. Haskell : De nouvelles voies pour le parallélisme. Journées nationales du Développe- ment Logiciel 2013, Sep 2013, Palaiseau, France. �hal-00909497�
Haskell : De nouvelles voies pour le parall´ elisme
Laurent Pierron
Institut National de Recherche en Informatique et Automatique
INRIA Nancy Grand-Est, 615 rue du Jardin Botanique, 54600 Villers-les-Nancy,
France
Exemple : r´esolution de grilles de Sudoku
◮ des probl`emes de Sudoku sont dans un fichier texte
◮ une ligne du fichier repr´esente un probl`eme
◮ fonction (solve :: String −> Maybe Grid) r´esoud une grille
Programme s´equentiel
◮ d´ecoupe le fichier de probl`emes en lignes
◮ avec map appelle le solveur pour chaque probl`eme (ligne)
main : : IO ( ) main = do
[ f ] <− g e t A r g s
g r i l l e s <− fmap l i n e s ( r e a d F i l e f )
l e t s o l u t i o n s = map s o l v e g r i l l e s −− 1 p r i n t ( l e n g t h ( f i l t e r i s J u s t s o l u t i o n s )
Parall´elisation : monade Eval
◮ d´ecoupage de la liste des grilles en deux listes ´egales `a une grille pr`es
◮ ´evaluation de chaque liste en parall`ele en for¸cant l’´evaluation
◮ attente du r´esultat de chaque ´evaluation
◮ concat´enation des r´esultats
◮ remplacement de la ligne 1 du programme s´equentiel par
( as , bs ) = s p l i t A t ( l e n g t h g r i l l e s ‘ d i v ‘ 2) g r i l l e s s o l u t i o n s = r u n E v a l $ do
as ’ <− r p a r ( f o r c e ( map s o l v e a s ) ) bs ’ <− r p a r ( f o r c e ( map s o l v e bs ) )
r s e q as ’ r s e q bs ’
r e t u r n ( as ’ ++ bs ’ )
◮ solution peu satisfaisante :
⊲ commandes de bas niveau
⊲ am´elioration limit´ee `a deux coeurs
⊲ traitement d´es´equilibr´e entre les deux listes Parall´elisation : fonction parMap
◮ ´ecriture d’une fonction g´en´erale pour parall´eliser la fonction map
⊲ fonction r´ecursive
⊲ ligne 2 cas trivial de la liste vide
⊲ ligne 4 ´evaluation de la fonction en parall`ele
⊲ ligne 5 appel r´ecursif
⊲ ligne 6 construction de la liste r´esultat
1 parMap : : ( a −> b ) −> [ a ] −> E v a l [ b ]
2 parMap f [ ] = r e t u r n [ ]
3 parMap f ( a : a s ) = do
4 b <− r p a r ( f a )
5 bs <− parMap f a s
6 r e t u r n ( b : bs )
◮ remplacement de la ligne 1 du programme s´equentiel par un appel `a notre fonction parMap
s o l u t i o n s = r u n E v a l ( parMap s o l v e g r i l l e s )
◮ cette fois le code est ´el´egant
Parall´elisation : monade Strategies (parList)
◮ fonction parMap a ´et´e g´en´eralis´ee dans la biblioth`eque Control.Parallel.Strat´egies qui d´efinit :
⊲ fonctions de parcours de structures de donn´ees
⊲ strat´egies d’´evaluation combinables
◮ modification de la ligne 1 du programme s´equentiel
s o l u t i o n s = map s o l v e g r i l l e s ‘ u s i n g ‘ p a r L i s t r s e q
◮ solution tr`es ´el´egante :
⊲ d´eveloppement et test du code en s´equentiel
⊲ ajout d’annotations pour parall´eliser
⊲ permet de tester plusieurs strat´egies de paral´ellisation
R´esultats sur quatre variantes de programme
◮ compilation : ghc -O2 sudoku.hs -rtsopts -threaded -threaded demande la parall´elisation
◮ ex´ecution : sudoku sudoku17.1000.txt +RTS -N4 -N4 indique le nombre de coeurs (ici 4)
0 1,00 2,00 3,00 4,00
1 coeur 2 coeurs 3 coeurs 4 coeurs 0,93
1,70
2,47
3,21
0,95
1,40 1,28 1,18
Performance pour 1000 grilles
Deux listes parMap parList parChunk 3
0 1,00 2,00 3,00 4,00
1 cœur 2 cœurs 3 cœurs 4 cœurs
0,92
1,71
2,50
3,24
0,91 1,07 1,20 1,20
0,94
1,71 1,60
1,42
Performance pour 16000 grilles
Concurrence : Software Transactional Memory
◮ un exemple de tranferts entre comptes en banque
◮ version Java multithreads
c l a s s Account { I n t b a l a n c e ;
s y n c h r o n i z e d v o i d w i t h d r a w ( i n t n ) { b a l a n c e = b a l a n c e − n ; }
v o i d d e p o s i t ( i n t n ) { w i t h d r a w ( −n ) ; }
}
v o i d t r a n s f e r ( Account from , Account to , I n t amount ) { from . l o c k ( ) ; t o . l o c k ( ) ;
from . w i t h d r a w ( amount ) ; t o . d e p o s i t ( amount ) ;
from . u n l o c k ( ) ; t o . u n l o c k ( ) ; }
⊲ attention au deadlock dans transfer
⊲ d´elicat `a mettre au point, car d´epend de la charge en threads
◮ version Haskell STM
t y p e Account = TVar I n t
w i t h d r a w : : Account −> I n t −> STM ( ) w i t h d r a w a c c amount = do
b a l <− r e a d T V a r a c c
w r i t e T V a r a c c ( b a l − amount )
d e p o s i t : : Account −> I n t −> STM ( )
d e p o s i t a c c amount = w i t h d r a w a c c (− amount )
t r a n s f e r : : Account −> Account −> I n t −> IO ( ) t r a n s f e r from t o amount = a t o m i c a l l y $ do
d e p o s i t t o amount
w i t h d r a w from amount
⊲ −> STM () : fonction utilis´ee dans m´emoire transactionnelle
⊲ atomically action implique pour action :
◮ atomicit´e : effets visibles de l’action d’un seul bloc
◮ isolation : actions internes pas affect´ees par autres threads
⊲ pas de deadlock dans la version Haskell
Quelques autres modules pour le parall´elisme
◮ Par monad : pour d´ecrire les d´ependances entre actions parall`eles
◮ Repa : calcul haute performance sur tableaux multidimensions
◮ Accelerate : distribution de calculs principalement sur GPU
◮ Async : pour la concurrence asynchrone
◮ forkIO, MVar : pour la concurrence `a un plus bas niveau que STM
◮ Pas de solution magique : biblioth`eques adapt´ees par type de probl`eme Pour en savoir plus
◮ Haskell : http://www.haskell.org
◮ Parallel and Concurrent Programming in Haskell by Simon Marlow : http://chimera.labs.oreilly.com/books/1230000000929
◮ Beautiful concurrency by Simon Peyton-Jones :
http://research.microsoft.com/pubs/74063/beautiful.pdf
Created with LATEXbeamerposter http://www-i6.informatik.rwth-aachen.de/~dreuw/latexbeamerposter.php
http://www.inria.fr Laurent.Pierron@inria.fr
