ch2_Algorithmes_para..

Université Du Havre, Master : Mathématiques-Informatique (Matis)
MIS7 : Modèles discrets: évolution, auto-organisation
2010/2011
Nakechbandi M.
moustafa.nakechbandi.univ-lehavre.fr
Chapitre 2 : Algorithmes et environnement parallèle et distribué

1. Parallélisme
2. La loi d'Amdahl
3. Architecture Parallèle
4. Algoritme systolique
5. Algorithme parallèle
6. Ordonnancement
plan

1. Parallélisme : Introduction.
Pour résoudre plus rapidement un problème donné, une idée naturelle consiste à faire
coopérer simultanément plusieurs agents à sa solution, qui travaillerons donc en parallèle // :
Si l’on veut monter plus rapidement un mur on fait appel à deux maçons a et b qui peuvent
organiser leur travaille de plusieurs manières :

On remarques plusieurs problèmes ralentissant le travaille en parallèle, par exemple :
- Les maçon se gênent mutuellement pour chercher les briques sur le même tas ou
pour les poser.
- Dans la méthode ci-dessus, les ils ne se gênent plus mais n’ont pas la même
distance de briques. Donc a avance plus vite que b.
- On remarque également un problème pour travailler sur la frontière commune.

Parallélisme : Exemple numérique, multiplication de deux matrices

Parallélisme : Pourquoi et Comment
• Pourquoi Paralléliser ?
– Gagner du temps
– La modélisation parallèle est parfois évidente
• Comment paralléliser ?
– Question non triviale
– Propre à chaque architecture
– Propre à chaque problème

Granularité
Comment découper les traitements ? Quelle sont les tailles des
tâches (en temps d'exécution) ?
Quand la tâche est petite (en temps d'exécution), on parle de parallélisme grain
fin. Quand la tâche augmente de taille, on parle de grain moyen
puis de gros grain.
Cela peut se faire par décomposition de domaines : diviser les
données, puis les calculs correspondants.
Exemple : multiplication de matrices
Cela peut aussi se faire par décomposition fonctionnelle : diviser les calculs,
puis les données correspondantes.

2. La loi d’Amdahl.
Soit A l’accélération apportée par un changement d'architecture.
Dans l'hypothèse où un gain de puissance est apporté par ce
changement d'architecture, quel est le gain espéré pour un
programme particulier ?
Hypothèses :
• Ao = l’amélioration
• Temps de calcul avant amélioration T = Tn + To
• Temps de calcul après amélioration T’ = Tn + To’
• T0, T0’ : durée de la partie modifiée
• Tn : dur de la partie non modifiée
• Fraction améliorée : F = To/T
Accélération = A = T / T’ = 1 / (1-F + F/Ao)

La loi d'Amdahl : Exemples
Exemple : Considérons un dispositif d'amélioration dix fois plus rapide que
la machine de base, mais que l'on ne peut utiliser que 40% du temps.
Déterminer l'accélération de la machine.
Solution
• Ao = 10
• Ao = 10
• F = 40/100 = 0.4
• A = 1 / (( 1 - F) + F/Ao)
= 1/ (0.6 + 0.4/10)
= 1/0.64 = 1.56

Exemple : Filtrage d’une image numérique
Le filtrage d’une image numérique passe par deux parties :
partie 1 (intrinsèquement séquentielle)
capture
chargement sur le serveur
Partie 2 (parallélisable)
découpage
calculs pour le
traitement de l'image en parallele
…
Exercice : En supposant que la partie 1 prend 20% du temps d'exécution du
programme précédent. L’introduction du parallélisme (utilisation d’une machine
multiprocesseur avec un algorithme // efficace) peut amélioré 10 fois la partie 2.
Déterminer l'accélération globale ?

3. Architectures parallèles : Motivation
• Les besoins des applications en puissance de traitement;
• Les limites de l'approche microprocesseur;
- Limite dans la capacité d'accès à la mémoire.
- La performance ne peut être résolue par un microprocesseur même
si l'évolution des performances des microprocesseurs suit une courbe
exponentielle dans le temps depuis 1985.
• L'existence de la propriété du parallélisme dans les applications :
- Parallélisme de données : la même opérations est réalisée par plusieurs
processeurs sur des données différentes:
exemple : addition de deux matrices;
- Parallélisme de contrôle : des opérations différentes sont réalisées simultanément.
indépendance/dépendance du flot
(architecture pipeline : dupliquer les unités de traitements).

Architectures parallèles : Définition
• Ordinateur parallèle : Ensemble de processeurs capables de travailler
en coopération de manière à résoudre un problème donné .
• Le parallélisme est une technique d'accroissement des performances
d'un système fondé sur l'exécution en parallèle de plusieurs processus.

Architectures parallèles : Organisation
• Construites à partir des ressources qui composent des architectures
séquentielles: UT, UC, mémoire, entrée/sortie (disque, réseau, etc);
• Durant l'exécution, toutes les unités échangent des informations à travers
une ressource supplémentaire : le réseau de communication interne.

Architectures parallèles : Classification (Flynn)
1 flux d'instructions >1 flux d'instructions
1 flux de données Séquentielle MISD (Pipeline)
> 1 flux de données SIMD MIMD

Architecture séquentielle: "de von Neuman"
Données
Données
Unité de
Traitement
Mémoire
Ordres
Unité de
Contrôle
Processeur
Instructions

Architecture MISD
- Conserve la même structure, mais les UT et les UC sont découpés en étages;
- Un seul flux de données reçoit plusieurs traitement simultanément;
- Il ne s'agit pas de machines multiprocesseurs, mais le parallélisme se situe au
niveau plus bas (au sein même du processeur)
Données
Étage 1 UT
Étage n UT
Données
Mémoire
Ordres
UC1
UC n
Processeur
Instructions

Exemple d’architecture MISD : Architecture pipeline
le traitement des instructions par le processeur peut se décomposer en cinq étapes :
< fetch > : recherche de la prochaine instruction à exécuter ;
< decode > : décodage de l'instruction, avec calculs éventuels des adresses ;
< read > : chargement des opérandes dans l'unit e d'exécution, par lecture à partir des
registres ou de la mémoire ;
< execute > : exécution proprement dite de l'instruction ;
< write > : écriture du résultat vers les registres ou la mémoire.
L’éxecution cette sequence d'instructions sur une machine pipelinee a cinq étages :

Le Modèle SIMD
- Seules les UT sont dupliquées;
- Une seule UC gère le séquencement du programme pour plusieurs UT;
- Toutes les UT fonctionnent en synchronisme et reçoivent les mêmes instructions
en même temps;
- La même opération est appliquée à plusieurs données simultanément, puisque
chaque UT calcule sur un flux de données différent.
Données
UTn UT1
Mémoire
Données
Ordres
Instructions
UC

Exemple de fonctionnement d’une machine SIMD :
Parfor i := 0, 3 //for parallèle
Y[i]=Y[i]+T[i] ;
Endpar for
Y=Y+T
Y[0] Y[1] Y[2]
T[0] T[1] T[2] ADD Y, Y, T
Y[0] Y[1] Y[2]
UT1 UT2 UT3 Mémoire du
programme

Le Modèle MIMD
- L'architecture du processeur du modèle séquentiel est dupliquée;
- Chaque processeur est libre d'exécuter des instructions qui lui sont propres sur
un flux de données qui lui est propre;
- Permet d'exécuter un programme différent sur tous les processeurs;
Données
Données
UT UC
ProcesseurN
Mémoire
Instructions
Données
UT UC
Processeur1
Instructions

Architecture MIMD à memoire distribuée

Grille de calcul
C’est une variante de l’architecture MIMD à memoire distribuée
Définition : Une grille de calcul est une infrastructure logicielle et matérielle(pc, supercalculateur,
cluster) qui procure à un utilisateur final un accès à des capacités de
calcul et de stockage de masse hautement distribué.
C’ est une infrastructure virtuelle constituée d'un ensemble de ressources
informatiques potentiellement partagées, distribuées, hétérogènes(l'hétérogénéité se
manifeste aussi bien au sein d'un réseau qu'entre deux réseaux), dé-localisées et
autonomes. L’utilisateur accède la grille à travers une interface standard. La
complexité liée aux différences doit être invisible pour l’utilisateur final.
L’idée : J’ai un accès, je me connecte, j’ai la ressource (stockage, base de données,
puissance de calcul, graphique, instruments de mesure, ... ), je n’ai pas à savoir où
elle est, je l’utilise.
Une grille de calcul permet de faire du calcul distribué : elle exploite la puissance de calcul
(processeurs, mémoires, ...) de milliers d'ordinateurs afin de donner l'illusion d'un
ordinateur virtuel très puissant. Ce modèle permet de résoudre d'importants
problèmes de calcul nécessitant des temps d'exécution très longs en environnement
"classique".
Grid’5000(Lyon, Grenoble), Grid’Mip(Toulouse)

Exemple d’une grille de calcul : Grid5000

Expression de parallélisme (architecture MIMD)
Primitive d’expression de parallélisme :
– On peux disposer de nouvelles primitives en pseudo code :
• Démarrer(tache(arguments))
Lance la tâche en parallèle, de manière non bloquante.
• Envoyer(P, message) et Recevoir(P, message)
Pour échanger des messages avec le processeur P.
– L’implémentation effective de ces primitives dépend du modèle et de
l’architecture :
Exemple : L’environnement MPI qui permet de programmer un ensemble de
PC connectés en reseau local ou d’etablissement.

4. Les algorithmes et réseaux systoliques. (Architecture mixte MISD
SIMD)
Il s'agit de réseaux d'automate cellulaire dont chacun effectue la même opération
arithmétique simple permettant de réaliser en parallèle des tâches répétitives.
L’exemple ci-dessous montre un réseau systolique pour la multiplication de matrices,
chaque unité effectue le produit de deux des entrées et ajoute le résultat à la
troisième entrée pour déterminer le signal de sortie.
Ces réseaux permettent la réalisation aisée sur silicium (systèmes VLSI) d e
processeurs dédiés (c'est-à-dire utilisables pour une seule fonction), extrêmement
rapides grâce au parallélisme, que l'on utilise à partir d'un ordinateur hôte.
Algoritme systolique : C’est le schema de controle permettant le fonctionnement
d’un reseau systolique.

Exemple : Réseau Systolique pour la multiplication de matrices (3x3)
alignments in time
rows of a
a 0,2 a 0,1 a 0,0
a 1,2 a 1,1 a 1,0
a 2,2 a 2,1 a 2,0
b 2,0
b 1,0
b 0,0
b 2,1
b 1,1
b 0,1
b 2,2
b 1,2
b 0,2
columns of b

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
alignments in time
a 0,2 a 0,1
a 1,2 a 1,1 a 1,0
a 2,2 a 2,1 a 2,0
a 0,0
b 2,0
b 1,0
a 0,0*b 0,0
b 0,0
b 2,1
b 1,1
b 0,1
b 2,2
b 1,2
b 0,2

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
alignments in time b 2,0
a 0,2
a 1,2 a 1,1
a 2,2 a 2,1 a 2,0
a 0,1
a 1,0
b 2,1
b 1,1
b 1,0 b 0,1
a0,0*b0,0 +a0,1*b1,0 a0,0 a0,0*b0,1 b 0,0
a 1,0*b 0,0
b 2,2
b 1,2
b 0,2

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
a 1,2
a 2,2 a 2,1
a 0,2
a 0,0*b 0,0
+a 0,1*b 1,0
+a 0,2*b 2,0
b1,0 a1,1 a1,0*b0,0 a1,0 +a1,1*b1,0 a 2,0
a 2,0*b 0,0
b 2,1
b 2,2
b 1,2
b 2,0 b 1,1 b 1,0
b 0,0
a 0,1
a 0,0*b 0,1
+a 0,1*b 1,1
b 0,1
a 1,0*b 0,1
a 0,0
a 0,0*b 0,2

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
a 2,2
a 1,2
a 2,1
a 0,0*b 0,0
+a 0,1*b 1,0
+a 0,2*b 2,0
a 1,0*b 0,0
+a 1,1*b 1,0
+a 1,2*b 2,0
b 1,0
a 2,0*b 0,0
a 2,1*b 1,0
a 0,2
b 2,1
a 0,0*b 0,1
+a 0,1*b 1,1
+a 0,2*b 2,1
a 1,0*b 0,1
+a 1,1*b 1,1
b 0,1
a 0,1
b 2,2
b 1,2
a 0,0*b 0,2
+a 0,1*b 1,2
b 2,0 b 1,1 b 1,0
a 1,1
a 2,0 a 2,0*b 0,1
a 1,0
a 1,0*b 0,2

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
a 2,2
a 0,0*b 0,0
+a 0,1*b 1,0
+a 0,2*b 2,0
a 1,0*b 0,0
+a 1,1*b 1,0
+a 1,2*b 2,0
a 2,0*b 0,0
+a 2,1*b 1,0
+a 2,2*b 2,0
a 1,2
a 0,0*b 0,1
+a 0,1*b 1,1
+a 0,2*b 2,1
b 2,1
a 1,0*b 0,1
+a 1,1*b 1,1
+a 1,2*b 2,1
a 0,2
a 1,1
b 2,2
a 0,0*b 0,2
+a 0,1*b 1,2
+a 0,2*b 2,2
b 2,0 b 1,1 b 1,0
a 2,1
a 2,0*b 0,1
+a 2,1*b 1,1
a 2,0
b 1,2
a 1,0*b 0,2
+a 1,1*b 1,2
a 2,0*b 1,0

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
a 0,0*b 0,0
+a 0,1*b 1,0
+a 0,2*b 2,0
a 1,0*b 0,0
+a 1,1*b 1,0
+a 1,2*b 2,0
a 2,0*b 0,0
+a 2,1*b 1,0
+a 2,2*b 2,0
a 2,2
a 0,0*b 0,1
+a 0,1*b 1,1
+a 0,2*b 2,1
a 1,0*b 0,1
+a 1,1*b 1,1
+a 1,2*b 2,1
b 2,1
a 2,0*b 0,1
+a 2,1*b 1,1
+a 2,2*b 2,1
a 1,2
a 2,1
a a0,0*b 0,0*b 0,2
+a +a0,1*b 0,1*b 1,2
+a0,2*b2,2 b 2,2
a 1,0*b 0,2
+a 1,1*b 1,2
+a 1,2*b 2,2
b 1,2
a 2,0*b 1,0
+a 2,0*b 1,1

Systolic Matrix Multiplication : Illustrated with two 3x3 matrices
a 0,0*b 0,0
+a 0,1*b 1,0
+a 0,2*b 2,0
a 1,0*b 0,0
+a 1,1*b 1,0
+a 1,2*b 2,0
a 2,0*b 0,0
+a 2,1*b 1,0
+a 2,2*b 2,0
a 0,0*b 0,1
+a 0,1*b 1,1
+a 0,2*b 2,1
a 1,0*b 0,1
+a 1,1*b 1,1
+a 1,2*b 2,1
a 2,0*b 0,1
+a 2,1*b 1,1
+a 2,2*b 2,1
a 0,0*b 0,0*b0,2 0,2
+a 0,1*b 0,1*b1,2 1,2
+a0,2*b2,2 a 1,0*b 0,2
+a 1,1*b 1,2
+a 1,2*b 2,2
b 2,2
a 2,2 a 2,0*b 1,0
+a 2,0*b 1,1
+a 2,2*b 2,2

Algoritme systolique : Exercices
1. Proposer un circuit systolique permettant de multiplier un vecteur (1..3) par une
matrice (1..3)*(1..3) dont la dimension est le plus petit possible et la
performance est le maximum possible.
Idem que l’exercice précédent pour un circuit permettant de comparer deux
2. Idem que l’exercice précédent pour un circuit permettant de comparer deux
mots (un mot est une chaîne de caractères)

5. Algorithme parallèle
• Qu’est-ce qu’un algorithme parallèle ?
Un algorithme parallèle est une méthode de résolution d’un problème dans
laquelle le problème est découpé en sous problèmes de taille inférieure
qui sont résolus de façon simultanée.
• Les différentes approches pour générer un code parallèle
– On peut soit paralléliser un code séquentiel existant en constituant un
graphe de taches puis lui appliquer des procédures d’ordonnancement
.
– Une autre approche consiste à reprendre le problème à partir de
l’énoncé puis concevoir un algorithme parallèle original solvant le
problème.

Domaines de recherche de l’algorithmique parallèle
• Algorithmes de recherche, de tri et de fusion, algorithmes génétiques.
• Algorithmes à caractère numérique : Opérations matricielles, systèmes
d'équations, méthodes directes et itératives
• Algorithmes reliés au traitement des images : Transformation, filtrage,
FFT parallèle.
• Techniques utilisées en traitement parallèle : Équilibrage de la charge,
ordonnancement, détection de fin du traitement.
• Tolérance aux pannes.
• Les outils de développement : Langage, environnement (MPI, PVM)
• Développement pour les Grilles de calcul (GRID).
• Étude de la complexité de calcul en parallèle(model théorique PRAM).

Notion de accélération (Speedup) et de d’efficacité
• Accélération (speed-up) =gain de temps obtenu lors de la parallélisation
du programme séquentiel.
Soit T1 le temps nécessaire à un programme pour résoudre le problème A sur un
ordinateur séquentiel et soit Tp le temps nécessaire à un programme pour
résoudre le même problème A sur un ordinateur parallèle contenant p
processeurs, alors l ’accélération (Speed-Up) est le rapport :
S(p) = T1 / Tp
• Efficacité : Soit T1(n) le temps nécessaire à l’algorithme pour résoudre
une instance de problème de taille n avec un seul processeur, soit Tp(n)
celui que la résolution prend avec p processeurs et soit s(n,p) = T1(n) /
Tp(n) le facteur d’accélération. On appelle efficacité de l ’algorithme le
nombre :
E(n,p) = S(n,p) / p

Exemple : Efficacité / Accélération
Multiplication de matrices ( A moins bon que B)
Algorithme A
Temps en séquentiel : 10 minutes
Nombre de processeurs : 10
Temps en // : 2 minutes
Accélération : 10/2 = 5 (l'application va 5 fois plus vite)
Efficacité : 5/10 = 1/2
Algorithme B
Temps en séquentiel : 10 minutes
Nombre de processeurs : 3
Temps en // : 4 minutes
Accélération : 10/4 = 5/2 = 2,5 < 5
Efficacité : (5/2)/3 = 0,8 > 0,5

6. Ordonnancement : Le model
Le modèle simplifié que nous allons utiliser est le suivant. :
• On part d'un ensemble de machines cible: Σ = {σ 1 , ..., σ s }
• On a également un graphe G des tâches (T,

Ordonnancement : Objectif
Ordonnancement : allocation de dates et de ressources aux tâches.
Diminuer le temps global de calcul : Optimisation d’un critère, d’une fonction
de coût :
· minimisation de la date de fin d’exécution de la dernière tâche (makespan),
. recherche du compromis entre équilibrage de la charge et minimisation du
surcoût dû aux communications...
Ordonnancement : statique, dynamique
. L'ordonnancement statique est une répartition avant exécution,
. alors que l'ordonnancement dynamique se fait pendant l'exécution
· modèles stochastiques : lorsque les durées d’exécution ou les tailles des
volumes communiqués sont des variables aléatoires définies par une
distribution (loi statistique : normale, géométrique, …) ou par des valeurs
avec probabilité.
Le problème posé ici de minimise stochastiquement la durée
d'ordonnancement .

Ordonnancement en présence de communications
le coût de communication dépend
de l'allocation des tâches en général.
Exemple : Machines connectées
par un réseau
à multi niveaux

Ordonnancement avec communications (classification)

Algorithme d’ordonnancement optimal avec duplication autorisée
(Colin, Chrétienne 1991: "Scheduling with Small Communication Delays and Task Duplication", P. C.P.M.
Operations Research vol. 39, n o 4, 680-684, 1991.)
- Lorsque les temps de communication sont plus grands que les durées d'exécution,
le problème est NP-difficile.
- Lorsque les temps de communications sont plus petits que les durées d'exécution,
le problème est polynomial. Un algorithme de complexité O(n 2 ) fournit un
ordonnancement au plus tôt.
Cet algorithme opère par trois phases :
La première phase détermine en parcourant les sommets du Graphe G dans l'ordre d'une
liste topologique, des dates au plus tôt bj pour les copies de chaque tâche. Soit j le
sommet en cours et s le prédécesseur de j tel que b s + p j+ c sj soit maximum. On a
alors:
où P RED(i) est l'ensemble des prédécesseurs de i dans G.

Algorithme d’ordonnancement optimal (suit)
La deuxième phase construit un grophe critique vis-à.-vis des dates b i , qui est le graphe
induit par les arcs (i,j) tels que b i + p i + c ij > b j . Si l'on veut en effet que deux
copies de i et de j soient exécutées respectivement aux dates b i et b j , elles devront être
exécutées sur un même processeur.
La troisième phase utilise le fait que le graphe critique soit une forêt couvrante de G pour
construire effectivement un ordonnancement où chaque copie est exécutée à sa date au
plus tôt. Chaque processeur exécute alors le chemin de tâches menant de la racine à une
feuille de la forêt critique. La figure ci-dessous montre les trois étapes de l'algorithme sur un
exemple.

Notre activité de recherche dans le domaine d’ordonnancement :
Notre projet de recherche porte sur l’impact des variations des paramètres de l’environnement
d’exécution (réseau multi niveau ou hiérarchique, processeurs ou réseaux hétérogènes ) sur la
qualité de l’ordonnancement avec communication :
- Architectures hiérarchiques : Dans ces architectures distribuées, les processeurs sont réunis
en clusters, avec des communications rapides entre les processeurs d’un même cluster, et des
communications plus lentes entre clusters. Nous avons un résultat [6] basé sur l’algorithme de
(Colin, Chrétienne 1991) qui a permis de proposer un algorithme polynomial optimal qui
détermine quels sont les groupes de taches qui peuvent, sans perte de performance, être
exécutés dans des clusters différents.
- Les durées d’exécution sont aléatoires : Nous avons proposé un algorithme construisant
efficacement un pré-ordonnancement statique pour ce type de problème [7].
- Problèmes d’ordonnancement lorsque les serveurs d’un réseau ont des performances
différentes ou lorsque le réseau lui-même est hétérogène : C’est typique des problèmes
d’exécution d’un programme distribué sur une grille de calcul, sous certaines hypothèses sur
les performances des serveurs, il était possible de calculer efficacement pour chaque tache sa
date d’exécution au plus tôt sur chaque serveur. A partir de premier résultat, un algorithme
polynomial construisant une solution optimale a été développé [8].
- La prise en compte des risques de pannes : Une évolution de l’algorithme précédent vers une
solution résistant à la panne d’un serveur dans un système de serveurs hétérogène est étudier
dans [9] .

Annexe
Machine parallèle : Un peu d’historique
Génèse d'un domaine
• 1950-70 : matériel. Challenge : construire une machine parallèle qui fonctionne.
• 1970-80 : matériel maîtrisé, machines commerciales. Nouveau défi : le logiciel.
• 1990 : programmation parallèle : affaire de spécialistes.
Défi : faciliter et systématiser la programmation parallèle. Emergence des réseaux
de stations et de PCs comme concurrents directs des machines massivement
parallèles ==> développement de nouvelles méthodes rapprochement avec
l'informatique distribuée.
Parallélisme informatique distribuée
• --> fin 80 : machines parallèles CM-2, CRAY XMP
• fin 80 --> mi-90 : + environnements hétérogènes locaux pvm , IBM SP-x, Origin
• mi-90 --> + environnements hétérogènes globaux ( metacomputing, grappes)
• GRID

Des machines plus récentes (2004)
SGI® Altix® ICE 8200 (2007) est un cluster de calcul sous un format de lames, dense et
ultra-compact. Il est basé sur des processeurs Intel Xeon quadri-coeurs et un réseau
d’interconnexion Infiniband.
L’Altix ICE 8200 peut évoluer jusqu’à plusieurs dizaines de milliers de processeurs (32.768
sockets) pour atteindre des performances au-delà du PetaFlops.
Pour la puissance du calcul au niveau mondial voir : http://www.top500.org/

Références
1. E. Garcia, Polycopié, LIFC Université de Franche Comté.
2. N. Hameurlain, Polycopié, Université de Pau.
3. H. El-Rewini (Auteur), Ted G. Lewis “Distributed and Parallel Computing”
ed. Manning, 1998.
4. M. Pérotin Synthèse des outils de parallélisation,, Polycopié, LI Tours
5. A. Legrand - Y. Robert Algorithmique Parallèle, ed. Dunod, 2003.
6. J.-Y. Colin, M. Nakechbandi., P. Colin, and F. Guinand "Scheduling Tasks with
Communication Delays on Multi-Levels Clusters" , M., PDPTA'99 : Parallel and Distributed
Techniques and Application, June 1999, Las Vegas, U.S.A.
7. M. Nakechbandi, J.-Y. Colin , C. Delaruelle, "Bounding the makespan of best preschedulings
of task graphs with fixed communication delays and random execution times on
a virtual distributed system", OPODIS02, Reims, pp 225-233 (2002).
8. M. Nakechbandi, J.-Y. Colin, P. Colin "A multi-valued DAG model and an optimal PERT-like
Algorithm for the Distribution of Applications on Heterogeneous Computing Systems",.
PDPTA'05, Las Vegas, Nevada, USA, pp 876-882 (2005).
9. M. Nakechbandi, J.-Y. Colin, “An Algorithm and Some Numerical Experiments for the
Scheduling of Tasks with Fault-Tolerancy Constraints on Heterogeneous Systems”,
HPCS’08 Nicosia, June 2008, Cyprus.