5.2 Implantation de la bibliothèque BSMLlib
5.2.3 Prévision des performances
L’un des principaux avantages du modèle BSP est son modèle de coût : il est simple mais suffisamment précis. Cela a par exemple été montré dans l’article [157] en utilisant la bibliothèque BSPlib [147]. Ce constat a été de nouveau démontré expérimentalement [171] avec la BSPlib, mais aussi avec la PUB, MPI et cela sur différentes architectures parallèles.
La prévision des performances nécessite que l’on puisse déterminer les paramètres BSP des machines que l’on utilise. C’est ce que fait par exemple le programme «probe» présenté dans [34]. Nous l’avons adapté pour la BSMLlib [C1]. La figure 5.12 donnée à la fin de ce chapitre présente la partie principale du programme.
Le tableau de la figure 5.11 présente les résultats obtenus en exécutant le programme «probe» de [34] (C+MPI) et notre «bsmlprobe» (BSMLlib avec l’implantation MPI du moduleComm) sur notre grappe constituée de 6 nœuds.
Quelques expérimentations ont été réalisées sur un programme (voir à la figure 5.11) qui calcule le produit scalaire de deux vecteurs, soit en utilisant des tableaux pour stocker les vecteurs, soit en utilisant des listes. Le code est donné à la figure 5.10. Ce programme utilise la fonctionfold_directqui est une réduction en une étape de calcul et une étape de communication/synchronisation (une super-étape BSP).
La formule de coût BSP deinprodest :n + 2 × p + (p − 1) × g + l. Les résultats expérimentaux et la
courbe des performances prévues sont présentés à la figure 5.11.
Il n’existe pas d’applications «réelles» écrites en BSML, mais quelques exemples de taille modeste, l’implantation de structures de données parallèles (voir au chapitre 8) et surtout les fonctions disponibles dans la bibliothèque standard BSMLlib. Nous reviendrons sur ce point dans le chapitre 13.
81 5.2. IMPLANTATION DE LA BIBLIOTHÈQUE BSMLLIB 0.4 0.5 0.6 0.7 0.8 0.9 1 1.1 0 10000 20000 30000 40000 50000 60000 70000 80000 90000 100000 temps (ms)
n: Longueurs des vecteurs (en Kfloats) Produit scalaire en BSML listes
tableaux prediction (avg) prediction (max)
C+MPI BSMLlib (MPI)
r g l r g l
478 25.2 623141 469 28.0 227512 r en Mflops/s, g en flops/mots et l en flops Figure 5.11 —Performances du produit scalaire
let determine_one_r niters n =
let a = 1./.3. and b = 4./.9. and z = Array.init n foi and y = Array.init n foi and x = Array.init n foi in
begin
start_timing();
for iter=1 to niters do
for i=0 to n−1 do y.(i)<−a∗.x.(i) +. y.(i); done;
for i=0 to n−1 do z.(i)<−z.(i)−.b∗.x.(i); done;
done;
stop_timing(); get_cost();
end
type mode = Max | Average let determine_r niters maxn mode =
let rec mklist n1 n2 = if n1>n2 then [] else n1::(mklist (2∗n1) n2) in
let ns = mklist 16 maxn in let mflops =
let f n = parfun (toMflops niters n) (determine_one_r niters n) in
List.map f ns in
let rs = List.map avgtime mflops in match mode with
| Average→(List.fold_left (+.) 0. rs)/.(float)(List.length ns)
| Max→(List.fold_left max 0. rs)
let determine_one_g_and_l niters h = let rest = h mod (bsp_p()−1) in
let size1 = h/(bsp_p()−1) in
let size2 = if rest=0 then size1 else size1+1
and create size = if size>0 then Some(Array.create size foi) else None in let v1 = create size1 and v2 = create size2 in
let msg pid dst =
let d = if pid<rest then 1 else 0 in
if pid=dst then None else if dst<rest+d then v2 else v1 in begin
start_timing();
for iter=1 to niters do put(mkpar msg); done;
stop_timing(); get_cost()
end
let determine_g_and_l niters maxh r r’=
let rec mklist n1 n2 = if n1>n2 then [] else n1::(mklist (n1+1) n2) in let hs = mklist (bsp_p()) maxh in
let timings = List.map (compose avgtime (determine_one_g_and_l niters)) hs in let g,l = leastsquares hs timings in
(g/.(float) niters)∗.r, (l/.(float) niters)∗.r, (g/.(float) niters)∗.r’, (l/.(float) niters)∗.r’
6
Certification deprogrammes BSML
Le contenu de ce chapitre étend le travail qui a été effectué dans les articles [R5] et [N2].
Sommaire
6.1 Introduction . . . 83 6.2 Présentation succinte de Coq . . . 84
6.2.1 Généralités . . . 84 6.2.2 Assistant de preuves . . . 84 6.2.3 Langage de programmation . . . 85 6.2.4 Coq et BSML . . . 87 6.3 Formalisation des primitives BSML . . . 88
6.3.1 Axiomes et paramètres . . . 88 6.3.2 Cohérence et acceptation de l’ajout des axiomes BSML . . . 90
6.4 Développements de fonctions certifiées . . . 90
6.4.1 Fonction certifiée utilisant unmkpar. . . 90 6.4.2 Fonction certifiée utilisant unapply . . . 92 6.4.3 Fonction de communication certifiée utilisant unproj . . . 93 6.4.4 Composition de vecteurs parallèles . . . 97
6.5 Création d’une bibliothèque BSMLlib certifiée . . . 99
6.5.1 Echange total . . . 100 6.5.2 Rassemblement d’un vecteur parallèle . . . 100 6.5.3 Demander et recevoir des valeurs d’autres processeurs . . . 101 6.5.4 Diffusion en 2 phases . . . 102 6.5.5 Réduction directe . . . 103 6.5.6 Décalage . . . 104 6.5.7 Fonction de tri parallèle . . . 104 6.5.8 Extraction de code . . . 105 6.5.9 Autres applications possibles . . . 106
6.A Code de l’extraction . . . 107
L
Aprogrammation fonctionnelle est un bon cadre de travail pour l’écriture et la preuve de programmes car, sans effet de bord, il est plus simple de prouver la correction des programmes et de les réutiliser en tenant compte de leurs propriétés formelles : la sémantique est dite compositionnelle. Le langage BSML (sans les traits impératifs ni les entrées/sorties) permet de concevoir des programmes parallèles purement fonctionnels. Sa sémantique est aussi compositionnelle. Se pose alors la question de la réalisation de programmes BSML certifiés, c’est-à-dire dont le résultat est toujours celui qui a été spécifié. Ce chapitre traite ce problème et nous utiliserons l’assistant de preuves Coq afin de founir une bibliothèque de fonctions BSML certifiées qui sera un large sous-ensemble de la bibliothèque standard de la BSMLlib.6.1 Introduction
Le système Coq [30, 254]1est un environnement (et un langage logique) pour le développement de preuves et qui est basé sur le Calcul des Constructions Inductives [75], unλ-calcul typé étendu avec des définitions
1Téléchargeable à l’adresse suivante :http://coq.inria.fr/. 83
inductives. La théorie des types est un bon cadre pour le développement de preuves de programmes
(notam-ment ceux fonctionnels [218]) car elle fournit une grande expressivité logique. Dans l’assistant de preuves
Coq, il existe une interprétation constructive des preuves, c’est-à-dire la possibilité de construire
automa-tiquement uneλ-terme à partir de la preuve d’une formule logique. Ainsi, dans un tel formalisme et grâce
à l’isomorphisme de Curry-Howard, une preuve de la formule∀x.P (x) ⇒ ∃y.(Q y x), appelée une
spé-cification, permet d’obtenir un programme correct qui vérifie en entrée la propriétéP (une pré-condition)
et fournit un résultat qui vérifieQ (une post-condition). Le programme extrait de la preuve (en oubliant les
parties logiques de la preuve [220]) est donc garanti par Coq pour bien réaliser la spécification donnée. On parle alors d’un programme certifié.
Nous allons maintenant nous intéresser à la spécification de programmes BSML et à leur développement (réalisation) en Coq. Tout d’abord, nous présenterons rapidement le système Coq (section 6.2). Nous pour-rons alors expliquer comment intégrer les primitives parallèles dans ce système (section 6.3) pour certifier des éléments de la bibliothèque BSMLlib et ainsi obtenir une bibliothèque certifiée (section 6.5).