D’un point de vue tr`es g´en´eral, une application parall`ele est d´ecomposable
en deux entit´es distinctes mais intimement li´ees. On trouve d’une part les
fonctions s´equentielles de calcul li´ees aux diff´erentes ´etapes algorithmiques de
l’application et d’autre part divers m´ecanismes de coordination regroupant
et liant ces fonctions de calcul. Une application parall`ele est donc un
ensem-ble constitu´e de fonctions de calcul s´equentielles et d’un harnais de
communication. C’est g´en´eralement dans cette deuxi`eme partie de code
que l’on prend en compte les caract´eristiques de la machine cible (allocation
des ressources, synchronisation, communication, etc.).
Recv I
Send I1,I2,I3,I4 Recv I
H = HISTO(I) H = HISTO(I) H = HISTO(I) H = HISTO(I)
H = SUMHISTO(H1,H2,H3,H4) I1,I2,I3,I4 = ROWBLOCK(I) Recv H1,H2,H3,H4 Send H Send H Recv I Send H Recv I Send H Recv I Send H
Figure 2.1: Exemple de harnais de communication
L’examen a posteriori d’applications parall´elis´ees “`a la main”
1montre
que l’exploitation du parall´elisme (`a travers la mise en œuvre des m´ecanismes
de coordination des calculs) n’utilise qu’un ensemble limit´e de techniques
et de sch´emas de parall´elisation r´ecurrents. Cette constatation est
partic-uli`erement ´evidente dans le cas d’algorithmes deTIbas niveau pour lesquels
le r´esultat final est obtenu par fusion de r´esultats interm´ediaires calcul´es sur
un ensemble de domaines issus d’une partition initiale. Le harnais de
com-munication utilis´e poss`ede alors toujours la mˆeme structure illustr´ee sur la
1
Par exemple, dans le corpus d’applications d´evelopp´ees pour la plate-forme Transvision
au LASMEA.
figure 2.1. Cet exemple d´ecrit succinctement la parall´elisation d’un
algo-rithme de calcul d’histogramme des niveaux de gris de l’image o`u rowblock
est la fonction g´erant la partition des images en bandes,seqhisto une fonction
s´equentielle de calcul d’histogramme et sum histo somme les histogrammes
calcul´es sur chaque bande.
A partir de l`a, on peut ˆetre tent´e de franchir un niveau d’abstraction
et d’encapsuler ce couple (fonctions s´equentielles-harnais de
communica-tion) sous la forme d’un constructeur g´en´erique r´eutilisable et param´etrable
par les fonctions de calcul sp´ecifiques `a une application donn´ee.
For-malis´ee par Cole[Col89] et Skillicorn[Ski90], cette approche d´ebouche sur
la notion de squelettes de parall´elisation. Un squelette est donc une
sp´ecification incompl`ete d’une forme de parall´elisme commune `a un grand
nombre d’applications, que le programmeur va sp´ecialiser avec ses fonctions
de calcul s´equentiel. Pour ce programmeur, l’implantation du squelette sur
une plate-forme est compl`etement cach´ee : les squelettes encapsulent tous
les aspects — placement, communications, synchronisations — relatifs `a
l’expression d’une forme de parall´elisme. En un sens, ils sont `a la
program-mation parall`ele ce que la programprogram-mation structur´ee est `a celle reposant sur
l’utilisation de instructions goto/label[BDP93].
Cette encapsulation des d´etails relatifs au parall´elisme offre des propri´et´es
extrˆemement int´eressantes. Premi`erement, le programmeur d’applications
voit son travail de parall´elisation fortement s’amoindrir puisqu’il n’a plus `a
traiter les aspects bas niveau d’implantation. Le travail de parall´elisation
est d`es lors limit´e auchoixet `a l’instanciation des squelettes en dehors de
toutes consid´erations sur les caract´eristiques de la machine.
Deuxi`emement, l’implantation d’un squelette sur une architecture
donn´ee, ´etant r´ealis´ee une fois pour toute, peut ˆetre pr´ecis´ement ´etudi´ee
et optimis´ee par le programmeur syst`eme garantissant ainsi une grande
effi-cacit´e.
Troisi`emement, ´etant donn´e que le programmeur d’applications voit son
travail r´eduit au d´eveloppement de fonctions de calcul s´equentiel (par
exem-ple dans un langage imp´eratif classique comme le C), une plus grande
porta-bilit´e des applications est garantie. En cas de changement architectural,
voire de migration vers une autre plate-forme, le travail de r´eimplantation est
limit´e au portage des squelettes par le programmeur syst`eme
2, la sp´ecification
des applications demeurant inchang´ee.
Quatri`emement, l’implantation d’un squelette sur une architecture ´etant
2
Notons tout de mˆeme que ce portage n’est pas forc´ement trivial mais qu’au moins,
celui-ci n’est effectu´e qu’une seule fois.
parfaitement connue, il est envisageable de mod´eliser son comportement et
d’en d´eduire un mod`ele analytique de performances param´etr´e `a la fois par
les caract´eristiques mat´erielles (nombre de processeurs, vitesse des liens, etc.)
et par les caract´eristiques algorithmiques (temps d’ex´ecution des fonctions
de calcul, type et taille des donn´ees, etc.).
En r´esum´e, les squelettes de parall´elisation offrent des propri´et´es
de sp´ecification haut niveau permettant de concilier des exigences
d’abstraction et d’efficacit´e du code. Ils r´epondent `a la plupart des
exi-gences d’un mod`ele id´eal de programmation parall`ele ´enonc´ees au chapitre
pr´ec´edent `a savoir facilit´e de programmation, ind´ependance vis `a vis de
l’architecture, efficacit´e des implantations et pr´ediction des performances. Un
outil de d´eveloppement bas´e sur ces constructeurs g´en´eriques semble donc
na-turellement bien plac´e pour satisfaire nos objectifs deprototypage rapide
d’applications sur architecture d´edi´ee.
Toutefois, malgr´e ces qualit´es, il subsiste une restriction majeure `a leur
utilisation en tant que mod`ele de r´ef´erence en programmation parall`ele. Ils
imposent en effet au programmeur de construire ses applications `a partir
d’une collection finie de constructeurs et rien ne peut garantir que cette
collection de constructeurs permettra de couvrirtoutes les applications
pos-sibles. La profusion de propositions, mise en ´evidence dans [Cam96] par
exemple, montre clairement les difficult´es rencontr´ees pour d´efinir une
“col-lection id´eale et polyvalente” de squelettes. Mˆeme en supposant qu’il soit
possible de produire une telle base “id´eale”, l’exploitation de celle-ci passerait
in´evitablement par le d´eveloppement d’une m´ethodologie de programmation
au sein de laquelle toute application pourrait ˆetre sp´ecifi´ee naturellement
sous la forme d’une composition des squelettes composant la base. Du fait
de ces inconv´enients, l’applicabilit´e des squelettes en tant que mod`ele g´en´eral
de programmation demeure incertaine.
Cependant, nous pouvons remarquer que les difficult´es li´ees `a la d´efinition
d’une collection de squelettes peut ˆetre amoindrie si l’on se place d´elib´er´ement
dans un domaine d’applications restreint. En effet, nous avons d´ej`a remarqu´e
que la mise en œuvre du parall´elisme au sein des applications — en particulier
dans le cas du TI — n’est bas´ee que sur un nombre restreint de sch´emas de
parall´elisation propres au domaine envisag´e. D`es lors, la d´efinition d’une
col-lection de squelettes peut ˆetre r´ealis´ee de mani`ere ascendante `a partir d’une
part de l’analyse a posteriori d’applications deTI implant´ees manuellement
et d’autre part de l’exp´erience accumul´ee par les programmeurs œuvrant dans
le domaine.
Cette restriction de la classe d’applications autorise alors le
Dans le document
Prototypage rapide d'applications parallèles de vision artificielle par squelettes fonctionnels
(Page 71-74)