  

CPARBA Calcul
parallèle. Techniques
de base
Tableau de bord / Mes cours / CPARBA / COURS

/ CPARBA Questionnaire 2 (2020-2021)

Commencé le mardi 16 janvier 2024,

23:53
État Terminé
Terminé le mercredi 17 janvier 2024,
01:15
Temps mis 1 heure 22 min
Note Pas encore évalué

Question 1

Terminé

Noté sur 1,00

Marquer la question

Considérez l’extrait de programme écrit en C

ci-dessous. L’objet de ce programme est
d’initialiser une matrice de 1000 lignes et de 3
colonnes en réalisant 3 opérations par
l’intermédiaire des appels de fonctions
calculus1(), calculus2() et calculus3()
appliquées à chaque ligne. La donnée d’entrée
de l’algorithme d’initialisation de la matrice est
un entier servant de « germe ». Vous
supposerez que le temps d’exécution de
chacune de ces fonctions est identique et égal
à CT ms. Vous supposerez également que
vous utilisez une machine multi-processeurs
équipée de mémoire partagée (ne considérez
pas les temps d’accès à cette mémoire).

#define ROWS 1000

#define COLUMNS 3
int calculus1( int );
int calculus2( int );
int calculus3( int );
int matrix[ROWS][COLUMNS];
void init_matrix( int seed )
{
int index;
matrix[0][0] = calculus1( seed );
matrix[0][1] = calculus2( matrix[0][0] );
matrix[0][2] = calculus3( matrix[0][1] );
for (index = 1; index<ROWS; index++)
{
matrix[index][0] = calculus1( matrix[index
matrix[index][1] = calculus2( matrix[index
matrix[index][2] = calculus3( matrix[index
}
}

Quelle solution pouvez-vous proposer pour

paralléliser cet algorithme et quelles sont les
raisons qui vous ont conduit à la retenir ? (Il
n’est pas nécessaire de donner une solution
programmée, seule la technique utilisée est
demandée.)

de données.
Cette technique consiste à diviser les
traiter chaque partie en parallèle sur
Dans le cas de cet algorithme, on peut
blocs de lignes et traiter chaque bloc
Chaque bloc peut être traité par un thr
d’exploiter les capacités de traitement
multi-processeurs.
La technique de parallélisme de données
algorithme car elle permet de traiter c
indépendamment des autres lignes.
Les fonctions calculus1(), calculus2()
chaque ligne de la matrice, et chaque l
indépendamment des autres lignes.
Par conséquent, il est possible de trai
parallèle sans affecter les autres bloc

La dépendance de données exposée par

l’algorithme permet une parallélisation de la
boucle en utilisant une technique de type
pipeline.

Question 2

Non répondue

Noté sur 1,00

Marquer la question

Considérez l’extrait de programme écrit en C

ci-dessous. L’objet de ce programme est
d’initialiser une matrice de 1000 lignes et de 3
colonnes en réalisant 3 opérations par
l’intermédiaire des appels de fonctions
calculus1(), calculus2() et calculus3()
appliquées à chaque ligne. La donnée d’entrée
de l’algorithme d’initialisation de la matrice est
un entier servant de « germe ». Vous
supposerez que le temps d’exécution de
chacune de ces fonctions est identique et égal
à CT ms. Vous supposerez également que
vous utilisez une machine multi-processeurs
équipée de mémoire partagée (ne considérez
pas les temps d’accès à cette mémoire).

#define ROWS 1000

#define COLUMNS 3
int calculus1( int );
int calculus2( int );
int calculus3( int );
int matrix[ROWS][COLUMNS];
void init_matrix( int seed )
{
int index;
matrix[0][0] = calculus1( seed );
matrix[0][1] = calculus2( matrix[0][0] );
matrix[0][2] = calculus3( matrix[0][1] );
for (index = 1; index<ROWS; index++)
{
matrix[index][0] = calculus1( matrix[index
matrix[index][1] = calculus2( matrix[index
matrix[index][2] = calculus3( matrix[index
}
}

Considérant la solution que vous avez

apportée à la question précédente, quelle
accélération en attendez-vous (justifiez votre
réponse) ?

L’accélération qui peut être obtenue est de

l’ordre du nombre de colonnes pour un
nombre élevé de lignes.

En effet, dans une solution de type pipeline, le

nombre d’étages mis en œuvre va
conditionner le débit de sortie. Si le nombre de
lignes est élevé, les temps de chargement et
de déchargement du pipeline deviendront
négligeables.

Question 3

Non répondue

Noté sur 1,00

Marquer la question

Considérez l’extrait de programme écrit en C

ci-dessous. L’objet de ce programme est
d’initialiser une matrice de 1000 lignes et de 3
colonnes en réalisant 3 opérations par
l’intermédiaire des appels de fonctions
calculus1(), calculus2() et calculus3()
appliquées à chaque ligne. La donnée d’entrée
de l’algorithme d’initialisation de la matrice est
un entier servant de « germe ». Vous
supposerez que le temps d’exécution de
chacune de ces fonctions est identique et égal
à CT ms. Vous supposerez également que
vous utilisez une machine multi-processeurs
équipée de mémoire partagée (ne considérez
pas les temps d’accès à cette mémoire).

#define ROWS 1000

#define COLUMNS 3
int calculus1( int );
int calculus2( int );
int calculus3( int );
int matrix[ROWS][COLUMNS];
void init_matrix( int seed )
{
int index;
matrix[0][0] = calculus1( seed );
matrix[0][1] = calculus2( matrix[0][0] );
matrix[0][2] = calculus3( matrix[0][1] );
for (index = 1; index<ROWS; index++)
{
matrix[index][0] = calculus1( matrix[index
matrix[index][1] = calculus2( matrix[index
matrix[index][2] = calculus3( matrix[index
}
}

Considérant la solution que vous avez apportée

pour les deux questions antérieures, de combien
de processeurs avez-vous besoin pour la mettre
en œuvre (justifiez votre réponse) ?

Le nombre de processeurs nécessaire est égal

au nombre d’étages du pipeline, c’est-à-dire
dans notre cas le nombre de calculs à réaliser
par itération, soit trois (correspondant aux
appels des trois fonctions).

Question 4
Terminé

Noté sur 1,00

Marquer la question

Quels commentaires vous inspire la définition

d’un système distribué donnée par Leslie
Lamport le 28 mai 1987 dans un mail interne
lorsqu’il travaillait pour la DEC Corp. : « A
distributed system is one in which the failure
of a computer you didn’t even know existed
can render your own computer unusable » ?

Leslie Lamport a défini un système dist

lequel la défaillance d’un ordinateur p
inutilisable .
Cette définition souligne les défis de
distribués, qui sont complexes en raiso
ordinateurs indépendants.

Citation ancienne : les systèmes distribués ont

beaucoup évolué.

Cette phrase a été écrite dans un contexte où

l’ingénierie logicielle et système pour ces
systèmes n’étaient pas matures : Leslie
Lamport demande à ce que ses collègues et
lui s’affairent à définir et concevoir une
infrastructure stable et sûre avant toute chose,
notamment avant même de vouloir s’en servir
pour réaliser des calculs complexes.

Elle met l’accent sur le fait qu’un système

distribué est constitué d’une multitude
d’équipements, et que, pour la plupart, vous
n’y avez pas un accès direct, voire vous n’y
êtes jamais confronté en temps normal : les
équipements fonctionnent derrière des
frontaux qui masquent la complexité de
l’infrastructure… jusqu’au moment où un
problème survient.

Il décrit la situation que tout un chacun peut

vivre au quotidien lorsqu’il est connecté à un
réseau informatique du fait du choix des
protocoles de communication utilisés et
d’implémentation des OS ou des applications
qui, parfois, insistent un peu trop à vouloir
rétablir à tout prix une connexion perdue
même si elle n’est pas essentielle à court
terme.

C’est un plaidoyer pour des systèmes qu’il faut

concevoir pour la haute-disponibilité et la
tolérance aux pannes.

Il rappelle aussi que les calculs distribués sont,

par nature, sensibles au moindre défaut de l’un
des nœuds du réseau ou de l’une de ses
interconnexions… sauf à les concevoir dès le
départ tolérants aux pannes.

La multiplication des unités de traitement

multiplie mécaniquement le risque que l’une au
moins d’entre-elles rencontre un
dysfonctionnement.

Question 5

Terminé

Noté sur 1,00

Marquer la question

Considérez un système multi-processeurs

disposant de 100 processeurs, chacun
d’entre-eux étant en mesure d’atteindre une
puissance crête de 2 Gflops (c’est-à-dire 2
milliards d’opérations à virgule flottante par
seconde). Quelle performance crête (mesurée
en Gflops) peut-on attendre de ce système s’il
exécutait une application où seulement 10 %
du code serait séquentiel et 90 %
parallélisable ? (Note : pour l’application
numérique, vous êtes autorisés à donner une
valeur approchée de certains résultats
intermédiaires.)

Performance crête = Performance crête p

Performance crête = (Performance crête

Performance crête = (2 Gflops) + (99 x

Performance crête = 200 Gflops

Ainsi, la performance crête du système

Supposons que S est le temps d’exécution

séquentiel de l’application, et N le nombre de
processeurs.

Le temps d’exécution de la partie parallélisable

de l’application est donc égal à 0,9xS .

Partant de l’hypothèse que nous puissions

observer une accélération linéaire dans la
partie parallélisable de l’application (cas le
plus favorable), le temps d’exécution pour
N=100 sera de 0,1xS + 0,9xS/N = 0,109xS .

Si l’ensemble de l’application avait pu être

parallélisée, alors le temps d’exécution aurait
été de S/N soit 0,01xS .

Par conséquent, l’efficacité de la parallélisation

est seulement de 0,01/0,109 = 9,17 %.

De ce fait, la performance crête qui peut être

atteinte avec le système proposé est de
0,0917x200 = 18,34 Gflops.

Sans calculatrice, une solution approchée

donne un temps d’exécution parallèle ~ 0,1xS
soit ~ 10 % d’efficacité et donc ~ 20 Gflops de
performance crête.

Question 6

Terminé

Noté sur 1,00

Marquer la question

Considérez le programme écrit en C et

utilisant MPI ci-dessous. Il fait circuler un jeton
sur un anneau en utilisant des communications
bloquantes et synchrones. Quel est l’erreur de
conception qui a été commise ici ?

#include "mpi.h"
#include <stdio.h>
int main( int argc, char ** argv)
{
int numtasks, rank, dest, source, rc, count,
char inmsg, outmsg='x';
MPI_Status Stat;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0) {
dest = 1;
source = 1;
rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest,
rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source,
}
else if (rank == 1) {
dest = 0;
source = 0;
rc = MPI_Recv(&inmsg, 1, MPI_CHAR, source,
rc = MPI_Send(&outmsg, 1, MPI_CHAR, dest,
}
rc = MPI_Get_count(&Stat, MPI_CHAR, &count);
printf("Task %d: Received %d char(s) from ta
rank, count, Stat.MPI_SOURCE, Stat.MP
MPI_Finalize();
}

L’erreur de conception dans ce programm

bloquantes et synchrones sont utilisées
l’anneau.
Cela signifie que chaque processus atte
terminée avant de continuer à exécuter
Dans ce cas, si un processus est bloqué
qui ne se produira jamais, tout le prog

Le programme n’est pas capable d’évoluer

avec le nombre de nœuds de calcul.

Question 7
Terminé

Noté sur 1,00

Marquer la question

Supposez une application de traitement

d’images réalisant une opération de seuillage
sur chaque pixel d’une image donnée en
entrée. Par conséquent, les traitements sont
indépendants les uns des autres et sans effet
de bord. Vous supposerez disposer d’une
topologie en anneau pour interconnecter vos
nœuds de calcul. Le nœud de rang 0 dispose
de l’intégralité de l’image d’origine, image
dont la taille sera notée S. Ce même nœud
distribue des imagettes (partition de l’image
d’origine) de dimension S/(N-1), où N est le
nombre total de nœuds de calculs impliqués
dans le traitement. L’imagette de rang X est
envoyée depuis le nœud 0 au nœud de rang X
(0<X<N). En fin de traitement, chaque nœud
retourne au nœud de rang 0 le résultat de ses
calculs sous la forme d’une image de
dimension S/(N-1). Le nœud de rang 0 ne
traite aucune des imagettes en propre : son
rôle se limite à distribuer les imagettes et
collecter les résultats des traitements. Quel
est le temps d’exécution de l’algorithme de
seuillage pour un nœud de calcul
arbitrairement choisi (travaillant sur une
unique imagette), connaissant le coût du
schéma de communication (s’appliquant donc
à l’ensemble des communications) C(N,S), et
le temps d’exécution global de la version
séquentielle de l’algorithme T ?

Le temps d’exécution global de la versi

T.
Le temps d’exécution de la partie séque
T * C(N, S)
Le temps d’exécution de la partie paral
T / (N - 1)
Par conséquent, le temps d’exécution de
un nœud de calcul arbitrairement choisi

T’ = (T * C(N, S)) + (T / (N - 1))

T / (N – 1)

Question 8

Terminé

Noté sur 1,00

Marquer la question

Quels sont les avantages et les inconvénients

de l’usage d’une mémoire distribuée par
rapport à une mémoire centralisée ?

Avantages :

scalabilité
accès local rapide
Disponibilité selon les besoins

inconvenients

difficulté de programmation
complexité de la communication des donn

Avantages : accès concurrents aux données

situées dans des mémoires différentes,
évolutivité de la solution (avec le nombre de
nœuds de calcul), simplicité (et coût faible) de
la solution technique.

Inconvénients : temps d’accès aux données

non uniforme (fonction de la localisation des
données par rapport au nœud de calcul qui
doit les traiter), pas d’espace d’adressage
global, modification des algorithmes, certaines
structures de données se prêtent difficilement
à son usage (listes chaînées,…).

Question 9

Terminé

Noté sur 1,00

Marquer la question

Quelle pourrait être la raison pour laquelle la

version parallèle d’un algorithme fonctionnerait
moins rapidement que sa version séquentielle
(on considère que l’application ne présente par
d’erreurs de programmation et que
l’architecture matérielle n’est pas en cause,
notamment qu’elle n’est pas
fondamentalement plus lente) ?

les raisons pourraient etre soit:

- un problème de communication
- un problème de synchronisation
- un problème de granularité
