Parallélisation d`une méthode d`illumination

Transcription

Université d’Auvergne
École doctorale Sciences pour L’Ingénieur
Laboratoire LAIC
Thèse
présentée par
Rita Zrour
et soutenue
le 24 octobre 2007
en vue de l’obtention du
Doctorat de l’Université d’Auvergne
Spécialité : Informatique
Titre
Parallélisation d’une méthode
d’illumination globale par voxels
Directeurs de thèse : Fabien Feschet
Rémy Malgouyres
Jury
M.
M.
M.
M.
M.
Eric ANDRES
Nicolas HOLZSCHUCH
Serge MIGUET
Fabien FESCHET
Rémy MALGOUYRES
Rapporteur
Rapporteur
Examinateur
Directeur de thèse
Directeur de thèse
Remerciements
Une thèse est un sujet de recherche qui demande un travail assidu bien structuré et
bien ciblé permettant d’atteindre le but majeur en se limitant à une période de temps
bien fixe ; cela n’est pas toujours facile. Or ce travail assidu est enrichi par les idées des
personnes qui entourent le chercheur et s’en trouve facilité par leur présence.
Je remercie tous les gens qui m’ont entouré et qui m’ont permis d’aller jusqu’au bout.
Avant tout, je remercie les membres du jury, les professeurs Eric Andres, Nicolas
Holzschuch et Serge Miguet pour leur collaboration durant l’examen de ce travail et leur
participation à la soutenance.
Je ne saurai jamais trop remercier Fabien Feschet et Rémy Malgouyres mes codirecteurs de thèse. Merci Fabien d’avoir toujours été disponible, merci aussi pour les
idées riches, nouvelles et les directions originales que tu as proposé. Merci pour ton
enthousiasme sans limite et tes encouragements aux bons moments. Merci pour ton
ambition d’avancer dans la recherche jusqu’au bout en partageant tes idées avec les
autres. À Rémy un grand merci pour les différentes idées très riches qui m’ont permis
d’avancer dans le domaine de la synthèse d’images. Merci pour les différents conseils
scientifiques variés dans différents domaines. Merci Rémy pour ton grand aide et ta
colaboration en enseignement qui m’a facilité la tâche et m’a permis d’avancer sans
difficultés. Merci pour ton aimabilité et ta chaleurosité.
Je remercie Pierre Chatelier de m’avoir aidé largement pour comprendre et démarrer
dans mon sujet de thèse ainsi que pour son aide en programmation avancée.
Je remercie également Thibault Marzais avec qui j’ai partagé bien plus qu’un bureau
et dont les nombreuses connaissances et les idées variées et riches m’ont aidés à avancer
dans le travail de ma thèse. Merci Thibault pour ton amitié et la bonne humeur que tu
as toujours.
Toute ma reconnaissance à mes collègues Alexandre Faure et Fabien Tixier pour leurs
différentes idées variés, leurs conseils, et leur sympathie.
J’adresse également mes remerciements à Nadia Amblard, Alex Esbelin, Mustapha
Fezani, Yan Gérard, Florent Madelaine, Malika More, Jean-Pierre Reveillès, et Carine
Simon pour leurs conseils et leurs remarques avisées.
Mes remerciements aussi à Abdel Hasbani, Frederic Jacquet, Marie-Alix LapaduHargues, Joel Toussaint, et Olivier Guinaldo pour leurs conseils et leur aide en enseignements.
Merci beaucoup à celles et ceux avec qui j’ai partagé de nombreuses escales : Florent
Brunet, François Champeau, Sophie Fleurdépine, Alain Gély, Aude Juquet, Anasthasia
Shtiliyanova, Pascal Bleuyard, Furby, et Thibault Langendorf.
Merci à mes amies : à Marina Ayoub et Sandy Rihana qui m’ont été un grand soutien
et qu’elles trouvent dans mes mots l’expression de ma plus profonde amitié.
i
Merci à mes amis Rany, Jinane, Remond, Charbel, Raghida, Mirvatte, Corine, Rabih,
Ali, Raluca, et Soumitra, et à tous mes amis Libanais à Clermont avec qui j’ai partagé
des moments inoubliables.
Merci à François Gaillard. Mon père j’admire toujours vos connaissances dans tous
les domaines, votre culture général assez variée, votre amour pour l’apprentissage et
votre curiosité scientifique. Merci pour vos conseils et votre tendresse.
Merci aussi à mes grand parents et à tous mes proches pour leurs encouragements.
Merci à ma soeur Catherine qui m’a toujours été un grand soutien dans différentes
escales de ma vie. Merci Catherine pour ton énorme patience, ta compréhension, tes
conseils toujours aussi sage.
Finalement merci à mes parents qui ont tant sacrifié pour moi avec beaucoup d’amour,
soutien, générosité et tendresse. Merci aussi à mes soeurs et mon frère qui m’ont tant
encouragés et qui sont pour moi une source de joie et de réconfort.
À mes parents
ii
Résumé
Les méthodes d’illumination globale dans le domaine de la synthèse d’images sont
devenues très populaires pour le calcul de l’éclairage de scènes en trois dimensions. Le
calcul d’illumination demande parfois une mémoire et un temps de calcul importants,
d’où le besoin du recours au parallélisme (division du travail sur plusieurs machines) afin
de minimiser à la fois le temps de calcul et l’encombrement mémoire.
Le but de cette thèse est de paralléliser la méthode d’illumination globale proposée par Chatelier et Malgouyres “A low complexity discrete radiosity method” sur des
grappes de stations de travail (cluster). Cette méthode est basée sur la discrétisation
de la scène en voxels. Elle utilise des notions de géométrie discrète pour résoudre le
problème de la visibilité entre les éléments.
Deux pistes de parallélisme sont possibles pour cet algorithme. La première suppose
que les voxels sont dupliquées sur les noeuds et donc aucune distribution des données
n’est effectuée. Deux parallélisations sont prévues dans ce cadre, la première est une
distribution du calcul et la deuxième est une parallélisation locale qui distribue les voxels
de la scène parmi plusieurs threads. La deuxième piste consiste à distribuer les données
entre les noeuds d’un cluster. Elle est plus complexe que la première et demande des
échanges de données entre les noeuds afin de mettre à jour correctement l’illumination
des voxels.
Les différentes parallélisations effectuées dans ce travail ont permis de minimiser le
temps de calcul et la mémoire permettant ainsi de traiter de grandes scènes qui n’entrent
pas en mémoire d’un unique ordinateur avec un temps de calcul optimisé.
iii
iv
Abstract
The global illumination methods are becoming very popular for simulating lighting
effects of 3D scenes in the domain of image synthesis. The computation of global illumination is expensive in terms of time computation and memory resources which leads
researchers to parallelize such computations on a distributed memory system trying to
minimize both time and memory.
The purpose of this work is to parallelize the global illumination method proposed
by Chatelier et Malgouyres, “A low complexity discrete radiosity method” on a cluster
of workstations. This method is based on the discretization of the scene into voxels. It
uses notions of discrete geometry in order to solve the visibility problem.
Two ways are possible for the parallelization of this algorithm. The first one supposes
that the voxels are duplicated on the cluster machines and so no data distribution is
accomplished. Two parallelizations are studied in this case. The first one is the distribution of the computation and the second one is a local parallelization that distributed
the voxels of the scene among threads. The second way consists in distributing data
between the cluster machines. It is more complex than the first stage since it demands
data exchange between the machines in order to correctly update the illumination of
voxels.
The different parallelizations accomplished in this work allowed the minimization of
the computation time as well as memory resources offering though the capability to treat
large scenes that do not fit in memory of one machine within an optimized computation
time.
v
vi
Table des Matières
Liste des figures
xi
Introduction
1
1 Parallélisme et architectures parallèles
1.1 Machine de Von Neumann . . . . . . . . . . . . . . . . . . .
1.2 Classification des architectures parallèles (Flynn) . . . . . .
1.3 Distribution ou partage de la mémoire . . . . . . . . . . . .
1.4 Classification unifiée réelle des architectures . . . . . . . . .
1.4.1 Les machines MIMD . . . . . . . . . . . . . . . . . .
1.4.2 Les machines SIMD . . . . . . . . . . . . . . . . . . .
1.5 Parallélisme de données et du contrôle . . . . . . . . . . . .
1.6 Critère d’évaluation . . . . . . . . . . . . . . . . . . . . . . .
1.6.1 Efficacité . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.2 Accélération . . . . . . . . . . . . . . . . . . . . . . .
1.7 Multi-ordinateurs et Communication . . . . . . . . . . . . .
1.7.1 Propriétés des réseaux d’interconnexion . . . . . . . .
1.7.2 Les modèles de communication . . . . . . . . . . . .
1.7.3 Logiciel de communication pour les multi-ordinateurs
1.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 Illumination globale, radiosité et parallélisme
2.1 Réflexion et réfraction . . . . . . . . . . . . . . . . .
2.2 Modèles d’éclairement . . . . . . . . . . . . . . . . .
2.2.1 Le modèle diffus idéal ou modèle Lambertien .
2.2.2 Le modèle spéculaire . . . . . . . . . . . . . .
2.2.3 BRDF : Bidirectional Reflectance Distribution
2.2.4 Angle solide, radiance et irradiance . . . . . .
2.2.5 Illumination locale . . . . . . . . . . . . . . .
2.2.6 Illumination globale . . . . . . . . . . . . . . .
2.3 Méthodes par lancer de rayons . . . . . . . . . . . . .
2.3.1 Pixels et rayons . . . . . . . . . . . . . . . . .
2.3.2 Modèle simple de lancer de rayons . . . . . . .
vii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . .
. . . . . .
. . . . . .
. . . . . .
Function .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
8
8
10
11
11
13
14
14
14
15
15
15
16
17
21
.
.
.
.
.
.
.
.
.
.
.
23
25
25
26
27
27
28
29
29
30
30
30
2.4
2.5
2.6
2.7
2.3.3 Algorithmes par lancer de rayons . . . . . . . .
Radiosité . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.1 Equation de la radiosité . . . . . . . . . . . . .
2.4.2 Discrétisation de l’équation de radiosité . . . . .
2.4.3 Résolution de l’équation de radiosité . . . . . .
2.4.4 Algorithmes avancés de radiosité . . . . . . . .
2.4.5 Radiosité utilisant l’approche Monte Carlo . . .
2.4.6 Autres algorithmes de radiosité . . . . . . . . .
État de l’art : parallélisation des méthodes de radiosité
2.5.1 Parallélisation de la radiosité progressive . . . .
2.5.2 Parallélisation de la radiosité hiérarchique . . .
2.5.3 Autres méthodes . . . . . . . . . . . . . . . . .
Illumination globale aujourd’hui . . . . . . . . . . . . .
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Méthode d’illumination globale par voxels : Algorithme et étude de
convergence
3.1 Notion de géométrie discrète . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Voxel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.2 Adjacence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.3 Chemin et connexité . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.4 Un k-Chemin . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.5 Composante connexe . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.6 Droites discrètes . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.7 Autres objets discrets . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.8 Partitionnement de l’espace . . . . . . . . . . . . . . . . . . . . .
3.2 La Radiosité : définition et équation . . . . . . . . . . . . . . . . . . . . .
3.3 Résolution de l’équation : méthode quasi-linéaire . . . . . . . . . . . . . .
3.3.1 Partitionnement de l’espace et visibilité . . . . . . . . . . . . . . .
3.3.2 Ordres lexicographiques . . . . . . . . . . . . . . . . . . . . . . .
3.3.3 Calcul de l’ensemble des directions . . . . . . . . . . . . . . . . .
3.3.4 Étapes de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . .
3.3.5 Complexités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5 Étude de convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.1 Scène de référence . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.2 Mesure d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.3 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
viii
30
35
35
36
39
41
45
46
47
48
50
52
53
54
55
55
56
56
57
57
58
58
59
59
61
62
63
63
65
65
67
69
70
71
71
72
74
4 Parallélisation locale et distribution du calcul
4.1 Description des machines utilisées pour le calcul parallèle . . . . . . .
4.1.1 Cluster Isima . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2 Cluster Laic . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Parallélisation locale . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Threads et programmation multithreadée . . . . . . . . . . . .
4.2.2 Utilisation des threads dans la méthode d’illumination globale
4.3 Distribution du calcul . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4 Résultats de la parallélisation . . . . . . . . . . . . . . . . . . . . . .
4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Distribution des données par répartition des listes
5.1 Description générale de la méthode . . . . . . . . . . . . . . .
5.2 Tri des directions . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Ordre lexicographique . . . . . . . . . . . . . . . . . .
5.2.2 Directions voisines . . . . . . . . . . . . . . . . . . . .
5.2.3 Tri final . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Distribution statique et dynamique des listes . . . . . . . . . .
5.3.1 Distribution statique des listes . . . . . . . . . . . . . .
5.3.2 Distribution dynamique des listes . . . . . . . . . . . .
5.4 Remplissage et échange des données . . . . . . . . . . . . . . .
5.5 Fusion des données . . . . . . . . . . . . . . . . . . . . . . . .
5.6 Étapes de l’algorithme d’illumination par répartition des listes
5.7 Parallélisation locale et distribution des données . . . . . . . .
5.8 Résultats et discussion . . . . . . . . . . . . . . . . . . . . . .
5.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Distribution des données par division de la scène
6.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Division de la scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Approche par topologie cartésienne et communications non bloquantes
6.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3.2 Application de la parallélisation . . . . . . . . . . . . . . . . . .
6.3.3 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4 Approche par communications collectives . . . . . . . . . . . . . . . . .
6.4.1 Matrices de communication . . . . . . . . . . . . . . . . . . . .
6.4.2 Remplissage de voxels . . . . . . . . . . . . . . . . . . . . . . .
6.4.3 Envoi et Réception . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.4 Mise à jour d’illumination . . . . . . . . . . . . . . . . . . . . .
6.5 Résultats et discussion . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5.1 Comparaison des deux approches de division de la scène . . . .
6.5.2 Parallélisation locale et distribution des données . . . . . . . . .
ix
.
.
.
.
.
.
.
.
.
75
75
76
76
76
76
78
85
88
88
.
.
.
.
.
.
.
.
.
.
.
.
.
.
91
91
93
93
94
95
95
96
98
100
103
103
104
105
108
.
.
.
.
.
.
.
.
.
.
.
.
.
.
109
109
110
111
111
113
113
115
115
118
118
119
119
121
122
6.5.3
6.6
6.7
Comparaisons de distribution des données par répartition des listes
et par division de la scène . . . . . . . . . . . . . . . . . . . . . . 123
Cumul les données et communications collectives . . . . . . . . . . . . . . 125
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
7 Améliorations de l’algorithme séquentiel et sa parallélisation
7.1 Amélioration de l’algorithme séquentiel . . . . . . . . . . . . . .
7.1.1 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1.2 Parallélisation locale . . . . . . . . . . . . . . . . . . . .
7.1.3 Parallélisation des données par division de la scène . . .
7.2 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
129
129
130
131
133
135
Conclusion
137
A Scènes en 3D
139
Bibliography
143
x
Table des figures
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
1.11
1.12
1.13
1.14
1.15
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
Machine de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . . .
Classification de Flynn . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Un réseau de machines à mémoire partagée . . . . . . . . . . . . . . . . .
Un réseau de machines à mémoire distribuée . . . . . . . . . . . . . . . .
Classification unifiée des ordinateurs parallèles . . . . . . . . . . . . . . .
Mémoire physiquement centralisée . . . . . . . . . . . . . . . . . . . . . .
Mémoire physiquement distribuée . . . . . . . . . . . . . . . . . . . . . .
Différentes topologies . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hypercube de dimension 0, 1, 2 et 3 respectivement . . . . . . . . . . . .
Un cube connecté de dimension trois . . . . . . . . . . . . . . . . . . . .
Une arbre binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Communications collectives . . . . . . . . . . . . . . . . . . . . . . . . .
Le reduce, additionnant des données de tous les processeurs . . . . . . . .
Une topologie virtuelle de 16 processeurs . . . . . . . . . . . . . . . . . .
Division d’un groupe en deux groupes chacun ayant son propre intracommunicateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le modèle spéculaire de Phong . . . . . . . . . . . . . . . . . . . . . . .
Le modèle Lambertien . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le modèle spéculaire de Phong . . . . . . . . . . . . . . . . . . . . . . .
Une BRDF et ses quatre paramètres (θin , φin , θout , φout ) . . . . . . . . . .
Angle solide pour une petite surface [SP94] . . . . . . . . . . . . . . . . .
Le rayon d’éclairement . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rayon réfléchi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La radiosité au point x depuis y dépend de la distance entre x et y et de
leurs orientations respectives . . . . . . . . . . . . . . . . . . . . . . . . .
Nusselt : illustration géométrique du facteur de forme . . . . . . . . . . .
Hémi-cube : calcul du facteur de forme . . . . . . . . . . . . . . . . . . .
Rassemblement des rayons provenant de plusieurs patchs vers le patch i .
Envoie de l’énergie du Patch i vers les autres patchs . . . . . . . . . . . .
Le quadtree utilisé pour la subdivision des éléments . . . . . . . . . . . .
Clustering : Pour des objets éloignés une seul lien est suffisant . . . . . .
Clustering : Pour des objets proche plusieurs liens sont nécessaire pour
plus de précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
xi
8
9
10
10
11
12
12
16
16
17
17
19
19
20
21
25
26
27
28
28
31
31
37
40
40
43
43
44
45
45
2.16 Génération locale de droites . . . . . . . .
2.17 Génération globale de droites utilisant une
of lines) . . . . . . . . . . . . . . . . . . .
2.18 Interface virtuelle [RAPP97] . . . . . . . .
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
3.17
3.18
3.19
3.20
3.21
3.22
3.23
4.1
4.2
4.3
4.4
4.5
4.6
. . . . . . . . . . . . . . . . .
génération parallèle (Bundle
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
Le point x et ses 4 voisins . . . . . . . . . . . . . . . . . . . . . . . . . .
Une droite continue sur une grille. Cette droite peut intersecter plusieurs
arêtes de la grille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Une droite discrète 2D : différente épaisseur avec (a, b) = (2, 1) . . . . . .
Une droite 3D discrète ayant un vecteur directeur (10, 7, 3) et ses deux
projections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Etant donné une direction ~σ et un point x, V (x, y) est une fonction de
visibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le parcours des voxels dans un ordre quelconque . . . . . . . . . . . . . .
Le parcours des voxels dans l’ordre lexicographique garantit la visibilité
entre les voxels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le choix de l’ordre lexicographique dépend du vecteur direction de la
direction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L’ensemble de directions est construit à partir d’une sphère discrète . . .
La propagation de la lumière dans les listes . . . . . . . . . . . . . . . . .
Une scène 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Temps de calcul en fonction du nombre de directions de l’algorithme séquentiel d’illumination pour la scène d’un salon . . . . . . . . . . . . . .
Temps de calcul en fonction du nombre de directions . . . . . . . . . . .
Effet de la variation du rayon de la sphère discrète sur l’erreur. Pas d’Epsilon
Effet de la variation du rayon de la sphère discrète sur l’erreur. Epsilon=10−5
Effet de la variation du rayon de la sphère discrète sur l’erreur. Epsilon=10−7
Effet de la variation du nombre d’itérations sur l’erreur. Pas d’Epsilon . .
Effet de la variation du nombre d’itérations sur l’erreur. Epsilon=10−5 . .
Effet de la variation du nombre d’itérations sur l’erreur. Epsilon=10−7 . .
Quatre activités exécutées en séquentiel . . . . . . . . . . . . . . . . . . .
Quatre activités exécutées en parallèle . . . . . . . . . . . . . . . . . . .
Des voxels classés dans l’ordre lexicographique et leur (i, j) pour une
direction donnée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Distribution des voxels sur trois threads . . . . . . . . . . . . . . . . . .
Création d’une structure de données distincte pour chacun des threads .
Regroupement des données des threads . . . . . . . . . . . . . . . . . . .
47
47
53
56
56
57
57
57
58
60
60
62
63
64
64
65
66
68
69
70
71
71
73
73
73
73
76
77
79
79
80
81
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
4.16
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
5.10
5.11
5.12
5.13
5.14
5.15
5.16
5.17
5.18
5.19
5.20
6.1
6.2
Après le regroupement des listes, les listes sont distribuées entre les threads
qui vont y propager la lumière . . . . . . . . . . . . . . . . . . . . . . . .
Le regroupement peut être évité . . . . . . . . . . . . . . . . . . . . . . .
L’effet de la variation du nombre de threads sur le temps . . . . . . . . .
Temps en fonction du nombre de directions scène d’une cabine . . . . . .
Temps en fonction du nombre de directions scène de l’église . . . . . . . .
Temps en fonction du nombre de directions scène de la salle de travail . .
Distribution du calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Echange d’illumination entre les voxels dupliqués sur les noeuds . . . . .
Distribution du calcul effectuée sur la scène d’un salon utilisant 2000
directions et 6 itérations . . . . . . . . . . . . . . . . . . . . . . . . . . .
Distribution du calcul effectuée sur la scène d’un salon utilisant 4597
directions et 6 itérations . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
82
83
83
84
84
85
86
87
88
La distribution des listes sur 3 noeuds différents . . . . . . . . . . . . . . 92
La distribution des listes entre les noeuds consiste à donner à chacun des
noeuds un intervalle (i, j) spécifique à traiter . . . . . . . . . . . . . . . . 94
Le nombre de voxels qui sort à l’extérieur d’un noeud sera minimisé . . . 94
Parcours de la sphère pour obtenir des directions voisines . . . . . . . . . 95
Distribution statique et déséquilibre du nombre de voxels . . . . . . . . . 96
Distribution dynamique des listes . . . . . . . . . . . . . . . . . . . . . . 97
Divisions par lignes et colonnes dépendant du nombre de noeuds . . . . . 99
L’effet d’augmention de la fréquence d’équilibrage de charge sur le temps 100
Le nombre de voxels est equilibré sur les noeuds en allant de 2 à 10 noeuds101
Distribution des données par répartition des listes entre les noeuds . . . . 102
Temps en fonction du nombre de noeuds scène de la cabine . . . . . . . . 104
Temps en fonction du nombre de noeuds scène de l’église . . . . . . . . . 104
Temps en fonction du nombre de noeuds scène de la salle de travail . . . 105
Distribution temporelle des différentes opérations (scène de l’église) . . . 106
Distribution temporelle des différentes opérations de la parallélisation
(scène de la salle de travail) . . . . . . . . . . . . . . . . . . . . . . . . . 106
Accélération en fonction du nombre de noeuds pour trois différentes scènes106
Accélération en fonction du nombre de noeuds pour la scène de l’église . 106
Accélération en fonction du nombre de noeuds scène de la salle de travail 107
Temps en fonction du nombre de noeuds pour la scène de la cabine avec
et sans threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Accélération en fonction du nombre de noeuds pour la scène de la cabine
avec et sans threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Echanges d’illumination entre les noeuds. Les échanges concernent le premier et le dernier voxel de chaque liste et leurs voisins en terme de visibilité
localisés sur les noeuds précédents ou suivants . . . . . . . . . . . . . . . 110
Distribution de la scène selon la densité . . . . . . . . . . . . . . . . . . . 111
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
6.14
6.15
6.16
6.17
6.18
6.19
7.1
7.2
7.3
7.4
7.5
7.6
Une topologie cartésienne à une dimension entre les noeuds . . . . . . . . 111
Les étapes de la transmission entre les voisins pour une topologie cartésienne112
Temps en fonction du nombre de noeuds utilisant une topologie cartésienne et des communications non bloquantes . . . . . . . . . . . . . . . 114
Accélération en fonction du nombre de noeuds utilisant une topologie
cartésienne et des communications non bloquantes . . . . . . . . . . . . . 114
Distribution du temps des différentes opérations utilisant une topologie
cartésienne et des communications non bloquantes pour la scène de la
cabine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Distribution du temps des différentes opérations utilisant une topologie
cartésienne et des communications non bloquantes pour la scène de l’église 115
Différentes étapes établies pour le calcul des matrices de communication . 117
L’effet de la compression sur les matrices de communications . . . . . . . 118
Temps en fonction du nombre de noeuds scène de la cabine . . . . . . . . 119
Temps en fonction du nombre de noeuds scène de l’église . . . . . . . . . 119
Temps en fonction du nombre de noeuds scène de la salle de travail . . . 120
Accélération en fonction du nombre de noeuds pour trois différentes scènes120
Distribution temporelle en fonction du nombre de noeuds utilisant des
communications collectives pour la scène de l’église . . . . . . . . . . . . 120
Distribution temporelle en fonction du nombre de noeuds utilisant des
communications collectives pour la scène de la salle de travail . . . . . . 120
Comparaison des temps des deux approches de division de la scène . . . . 122
Temps en fonction du nombre de noeuds. Comparaison des deux approches de distribution des données . . . . . . . . . . . . . . . . . . . . . 123
Accélération en fonction du nombre de noeuds. Comparaison des deux
approches de distribution des données . . . . . . . . . . . . . . . . . . . . 124
Propagation de la lumière surplace : le (i, j) de chacun des voxels est
calculé, la lumière est propagée entre le voxel courant et le dernier voxel de
la droite (i, j). Ensuite le voxel courant est maintenu en mémoire comme
étant le dernier pour la droite (i, j) . . . . . . . . . . . . . . . . . . . . .
Temps en fonction du nombre de directions . . . . . . . . . . . . . . . . .
Chacun des threads maintient en mémoire le premier et le dernier voxel
de chacune des droites non vides . . . . . . . . . . . . . . . . . . . . . . .
Temps en fonction du nombre de directions de l’algorithme séquentiel
amélioré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Temps en fonction du nombre de noeuds de la distribution des données
par division de la scène . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accélération en fonction du nombre de noeuds de la distribution des données par division de la scène . . . . . . . . . . . . . . . . . . . . . . . . .
131
132
133
134
135
136
A.1 Scène d’une église . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
A.2 Scène d’une salle de travail . . . . . . . . . . . . . . . . . . . . . . . . . . 140
xv
A.3 Scène d’une chambre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
A.4 Scène d’une cabine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
A.5 Scène d’un salon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
xvi
Introduction
La nature offre des spectacles fabuleux, perçus par le système visuel humain. Parmi
ces spectacles on peut citer par exemple, le coucher du soleil, l’orage, les étoiles, le clair
de lune, les nuages et l’arc en ciel. De nos jours grâce aux progrès dans le domaine de la
synthèse d’image, il est possible de simuler tous ces spectacles ou phénomènes naturels en
utilisant des ordinateurs. Ces simulations apparaissent très réalistes de sorte qu’il n’est
pas possible de discerner qu’elles correspondent à des images générées par ordinateur.
Les images générées par ordinateur sont utilisées dans de nombreux domaines. Les
images de synthèse peuvent être utilisées pour créer les effets spéciaux. Elles jouent un
rôle important dans les jeux vidéos, qui de nos jours se rapprochent de plus en plus du
cinéma et constituent une industrie en pleine effervescence. Le domaine de la médecine
se sert aussi des images de synthèse pour simuler virtuellement les opérations facilitant
par là, la tâche des médecins. Finalement la génération d’images par ordinateur est très
utilisée dans le domaine de l’architecture qui nécessite la reconstruction des bâtiments
avec une simulation précise de l’ambiance lumineuse des pièces intérieures.
La génération d’images de synthèse la plus réaliste possible requiert une prise en
compte des phénomènes optiques comme la réflexion et l’interaction lumière matière
permettant de simuler le trajet de la lumière partant d’une source lumineuse et interagissant avec les objets de la scène. Les méthodes d’illumination globale permettent la
simulation de tels phénomènes optiques en prenant en compte non seulement les effets
directs d’éclairement mais aussi les effets indirects résultant des inter-réflexions entre les
surfaces.
Les premières générations d’images de synthèse ne fournissaient pas des images très
réalistes. Ce n’est que dans les années 80 que les méthodes de rendu réaliste, le lancer
de rayons(ray tracing) et la radiosité sont apparus. Avec le temps, plusieurs méthodes
d’illumination globale ont été proposées comme les méthodes avancées de radiosité, les
méthodes basées sur le lancer de rayons (photon mapping) et les méthodes à base de
Monte Carlo.
Pour ces algorithmes d’illumination globale, lorsque le réalisme et la précision sont
de rigueur, le temps de calcul de la simulation peut augmenter surtout quand il s’agit
de scènes complexes. On utilise alors largement le parallélisme qui est l’approche idéale
pour minimiser le temps de calcul et les ressources mémoire.
Le travail de ce mémoire consiste à paralléliser l’algorithme de P. Chatelier et R. Malgouyres dans [CM06] sur le calcul d’illumination par voxels.
1
Introduction
2
Cet algorithme se caractérise par le calcul de la visibilité avec une complexité optimale. Il est basé sur la discrétisation des surfaces en voxels pour le calcul d’illumination. Un ensemble de directions utilisé pour le calcul d’illumination est généré à partir
d’une sphère discrète. Plusieurs itérations sont nécessaires pour garantir la convergence
vers la bonne solution d’illumination. Des listes de visibilité sont construites. Ces listes
contiennent les voxels de la scène qui sont voisins en terme de visibilité. À chaque changement de direction, de nouvelles listes de visibilité sont créées et une phase de mise
en place et de propagation de lumière dans les listes est mise en oeuvre. La propagation concerne les voxels voisins en terme de visibilité. La complexité de l’algorithme
est linéaire et augmente en fonction du nombre d’itérations ainsi que du nombre de
directions.
Objectif et problématique
L’algorithme d’illumination de P. Chatelier et R. Malgouyres [CM06] inclut une
grande constante, égale au nombre d’itérations multiplié par le nombre de directions et
dont dépend directement la complexité. La complexité est aussi liée au nombre de voxels
présents dans la scène. Quand ces nombres augmentent, le parallélisme offre un moyen
de réduire la complexité en influençant sur le temps de calcul ainsi que les ressources
mémoire.
Le but de cette thèse est de paralléliser l’algorithme d’illumination globale [CM06]
sur des machines à mémoire distribuée, des grappes de stations de travail ou cluster.
Cela permettra d’accélérer le temps de calcul de l’algorithme d’illumination et aussi de
traiter de grandes scènes qui n’entrent pas en mémoire RAM tout en minimisant au plus
le temps de calcul. Plusieurs approches permettant de réaliser cet objectif sont possibles.
Deux pistes de parallélisme sont conçues pour cet algorithme, la première regroupe la
distribution du calcul et la distribution locale et la deuxième comprend la distribution
des données. Elles peuvent se résumer comme suit :
Distribution du calcul et distribution locale
La dépendance de l’algorithme sur le nombre de directions (pouvant atteindre quelques
milliers) crée une première piste pour une première parallélisation. C’est une distribution
du calcul, répartissant les directions entre les noeuds du cluster. Cette première parallélisation est assez aisée, traitant des calculs relativement indépendants, et nécessitant
ainsi très peu d’échanges entre les noeuds du cluster. Elle ne distribue pas les données,
les voxels sont dupliqués sur tous les noeuds.
Une deuxième parallélisation est également possible pour cet algorithme, c’est la
distribution locale, qui suppose que les données soient toutes présentes en mémoire d’un
noeud ; elle distribue les voxels entre des threads pour être traités en parallèle.
Ces deux parallélisations sont intéressantes pour minimiser le temps de calcul, mais
elles ne distribuent pas les données et elles ne sont donc pas valables quand les scènes
dépassent en taille la mémoire RAM d’un noeud.
Introduction
3
Distribution des données
L’affaire commence à se compliquer et devient plus sérieuse lorsqu’on désire traiter de
grandes scènes qui n’entrent pas en mémoire et qui nécessitent alors la distribution des
données et donc des voxels. Dans l’algorithme d’illumination, la dépendance en terme
de visibilité entre les voxels rend difficile la procédure de la parallélisation des données.
En effet pour le calcul d’illumination deux voxels voisins en terme de visibilité doivent
être localisés sur un même noeud pour pouvoir échanger la lumière. Si ce n’est pas le
cas, une communication entre les noeuds, à l’aide d’une librairie de communications
(MPI), doit être faite pour accomplir cet échange. Ne pas oublier dans ce cadre que
l’augmentation du nombre et de la quantité de communications engendre des pertes en
temps de calcul. La problématique qui se pose est de trouver la meilleure manière de
paralléliser l’algorithme de sorte à minimiser les échanges entre les noeuds. De même
comment gérer les échanges en terme de structures de données, types de communication
(non bloquantes, collectives...) afin de les optimiser au mieux.
Il faut noter que la distribution des données constitue une partie essentielle et délicate
de notre travail. Elle sera étudiée en détail avec les différentes méthodologies envisagées
permettant de réaliser cet objectif.
Démarche et Plan
Le document que nous présentons ici est organisé de la manière suivante. Dans un
premier chapitre, nous présentons une introduction au parallélisme. Nous étudions alors
les différentes architectures parallèles ainsi que la distribution ou partage de la mémoire
sur les machines. Nous parlerons aussi de la classification unifiée réelle des architectures
ainsi que de la parallélisation du contrôle et des données. Ce chapitre donne la définition
de l’efficacité et de l’accélération qui permettent l’évaluation d’un algorithme parallèle
par rapport à la version séquentielle. Nous faisons aussi une étude des multi-ordinateurs
et des réseaux d’interconnexion de ceux-ci, ainsi que des logiciels de communication. La
communication entre les noeuds se fait à travers la librairie MPI. MPI est présentée avec
ses modes de communications, ses types de données, les topologies qu’elle utilise et les
notions de groupes qu’elle offre.
Le Chapitre 2 présente les notions de base de synthèse d’images et d’infographie.
Dans ce chapitre, on étudie les modèles d’illumination globale. On présente des notions importantes pour les échanges d’énergie comme la radiance et l’irradiance. Nous
exposons aussi le principe du lancer de rayons utilisé pour la simulation des échanges
énergétiques, en donnant une description des différents algorithmes qui l’utilisent. Le
système d’équations utilisé pour calculer effectivement la radiosité est ensuite présenté
en détail ; il faut noter dans ce cadre que la méthode d’illumination que nous cherchons
à paralléliser présente des points communs avec la radiosité, notamment la résolution
d’un système linéaire. Les définitions et les diverses méthodes de calcul de facteur de
forme sont résumées. Enfin, les méthodes avancées de radiosité sont expliquées et un
état de l’art sur les différentes parallélisations des méthodes de radiosité est détaillé.
Introduction
4
Dans le chapitre suivant, nous décrivons l’algorithme séquentiel de calcul d’illumination globale par voxels, proposé par P. Chatelier et R. Malgouyres [CM06]. Ce chapitre
introduit des notions de géométrie discrète qui sont essentielles pour comprendre l’algorithme séquentiel d’illumination. Ensuite l’équation de radiosité est décrite, ainsi que
sa discrétisation [Mal02b]. L’algorithme de résolution de l’équation discrétisée est expliqué. Cet algorithme représente l’algorithme séquentiel d’illumination, il est basé sur
des notions de géométrie notamment le partitionnement de l’espace en droites discrètes.
Les droites discrètes sont les listes de visibilité pour l’algorithme séquentiel et les voxels
voisins d’une même liste sont voisins en terme de visibilité. La complexité de l’algorithme est notée et les résultats testés sur différentes scènes sont montrés. Finalement
une étude de convergence de l’algorithme d’illumination est réalisée, montrant l’influence
du nombre d’itérations et du nombre de directions sur la solution exacte.
Les Chapitres 4, 5 et 6 détaillent les différentes parallélisations de l’algorithme. Le
Chapitre 4 décrit l’architecture des machines (grappes de stations de travail (cluster of
workstations)) utilisées pour tester les différentes parallélisations effectuées au cours de
cette thèse. Il explique la distribution locale utilisant des threads ainsi que la distribution
du calcul. Aucune distribution des données n’est menée dans ce chapitre. La parallélisation locale distribue les voxels de la scène parmi les threads, les voxels sont tous présents
en mémoire d’un noeud donné. La distribution du calcul se fait sur les différents noeuds
et nécessite une duplication des données sur chacun des noeuds du cluster, donc aucune distribution des données n’est conduite. Le Chapitre 5 présente une distribution
des données par répartition des listes. Les listes et donc les voxels sont répartis sur les
différents noeuds du cluster. Une transition de voxels entre les noeuds est nécessaire
à chaque direction afin de garantir une construction de listes complètes de voxels sur
chacun des noeuds. Le Chapitre 6 explique la distribution des données par division de
la scène en sous-environnements selon la densité des voxels. Ces sous-environnements
sont distribués parmi les noeuds du cluster. Des échanges d’informations entre les voxels
voisins en terme de visibilité d’une même liste mais localisés sur des noeuds distincts
sont réalisés. Ce chapitre propose deux façons de mener ces échanges entre les noeuds.
La première consiste à utiliser une topologie cartésienne et à effectuer des communications non bloquantes en communiquant les informations de radiosité entre les noeuds qui
sont des voisins directs seulement. La deuxième consiste à utiliser des communications
collectives et communiquer les informations de radiosité du noeud courant avec le noeud
impliqué même s’ils ne sont pas des voisins directs. Finalement, une comparaison des
deux méthodes de distribution des données (par répartition des listes (Chapitre 5) et par
division de la scène) est menée pour comparer le temps de calcul de ces deux approches.
Le Chapitre 7 présente une amélioration de l’algorithme séquentiel d’illumination.
Nous procédons dans ce chapitre à une combinaison des deux étapes essentielles de
l’algorithme séquentiel en une seule. Nous adoptons également dans ce chapitre la parallélisation des données étudiée au Chapitre 6 avec les améliorations effectuées.
Les conclusions et perspectives font l’objet du dernier chapitre. Pour résumer, la distribution du calcul est la parallélisation idéale pour les scènes qui tiennent en mémoire.
Introduction
5
Lorsque les scènes ne tiennent pas en mémoire RAM d’un ordinateur, une distribution
des données doit être appliquée ; celle-ci distribue les données en minimisant le temps
de calcul. Concernant les perspectives et dans un contexte plus général, on peut dire
que la méthode séquentielle d’illumination proposée par P. Chatelier et R. Malgouyres,
et parallélisée dans ce présent travail, constitue une partie importante dans le développement d’un moteur de rendu par illumination globale efficace. Dans ce chapitre, nous
mettons aussi en évidence les perspectives prometteuses de l’algorithme d’illumination,
algorithme qui comportera une partie d’un algorithme de lancer de rayons en cours de
réalisation par le doctorant Lukasz Piwowar.
Introduction
6
Chapitre 1
Parallélisme et architectures parallèles
Au cours des premières années de l’histoire de l’informatique, toutes les machines
furent des machines séquentielles. Ces machines utilisent un seul processeur pour résoudre un problème donné. Avec le temps, ces processeurs ont évolué et sont devenus
plus rapides, néanmoins la rapidité de ceux-ci reste toujours limitée ; cette limitation
vient du fait que la performance qu’un seul processeur peut atteindre reste toujours bornée. Le parallélisme s’est posé comme un concept ou une solution permettant d’améliorer
les performances des ordinateurs. Dès les années 50, les premiers essais pour construire
des machines parallèles ont commencé, mais c’est seulement durant les années 60 que ce
concept théorique a pu être réalisé concrètement et que les premières vraies machines
parallèles (des calculateurs mono-processeurs) sont apparues. Dans les années 70 les
machines multiprocesseurs apparaissent.
Les machines adoptées pour le calcul parallèle ont évolué avec le temps et ont atteint
actuellement des capacités de traitement permettant des calculs parallèles rapides et
efficaces. De nos jours le parallélisme est devenu très important et son application s’est
énormément étendue. On voit alors apparaître les processeurs multi-cœurs, composés
d’au moins deux cœurs sur le marché. Ce type d’architecture permet d’augmenter la
puissance de calcul sans augmenter la fréquence d’horloge, et donc de réduire la quantité
de chaleur dissipée.
Le recours au parallélisme ouvre deux perspectives de gains : le temps de calcul et la
mémoire. Ces gains offerts par le parallélisme, lui permettent d’être un outil important
dans de nombreux domaines comme la modélisation et la simulation (océanographie,
prédiction météorologique), l’ingénierie (la mécanique, la robotique et la chimie), en
traitement d’images et imagerie médicale, en synthèses d’images, en visualisation scientifique et beaucoup d’autres domaines.
Lors d’une parallélisation manuelle d’un algorithme, il est important de considérer
la stratégie du parallélisme, le niveau du parallélisme ainsi que la machine adoptée. La
stratégie du parallélisme est énormément liée à l’algorithme séquentiel. Elle constitue la
base de la parallélisation et nécessite un découpage délicat pour la distribution des tâches
ou des données entre les processeurs. Pour le niveau du parallélisme, on en distingue
7
Chapitre 1. Parallélisme et architectures parallèles
8
Fig. 1.1 – Machine de Von Neumann
plusieurs ; le parallélisme peut s’effectuer au niveau du programme, de la procédure, de
l’instruction ou à l’intérieur d’une instruction [CT93]. Du point de vue machine adoptée
pour le calcul parallèle, plusieurs architectures existent de nos jours, le choix de celles-ci
est lié à l’application souhaitée ainsi qu’à la disponibilité des machines qui parfois sont
coûteuses à l’achat, ce qui limite leur disponibilité.
Ce chapitre introduit différentes notions concernant le parallélisme, telles que la machine de Von Neumann, la classification des architectures parallèles, la distribution ou la
partage de la mémoire, le parallélisme du contrôle et des données, et les critères d’évaluation d’un algorithme parallèle. Il traite aussi des communications qui sont à la base de
toute programmation parallèle pour les multi-ordinateurs (machines à mémoire distribuée). Il décrit aussi les réseaux d’interconnexion ainsi que les modèles et la bibliothèque
utilisée pour les communications dans ce genre de machines.
1.1
Machine de Von Neumann
En 1945 Von Neumann écrivit un rapport dans lequel il proposa l’architecture interne
d’un calculateur universel (ordinateur), connu sous le nom architecture de Von Neumann.
Ce calculateur était le meilleur de son temps et constitue toujours aujourd’hui la base de
tous les ordinateurs. La machine de Von Neumann est constituée de l’unité arithmétique
et logique ou unité de traitement, la mémoire, l’unité de contrôle ou unité de commande,
l’entrée et la sortie. La Figure 1.1 montre ce modèle. L’unité arithmétique et logique et
l’unité de contrôle constituent la base ou le “cerveau” [Tan05] de l’ordinateur.
1.2
Classification des architectures parallèles (Flynn)
Le terme de “parallélisme” reste cependant vague si l’on ne précise pas le type des
architectures parallèles qui peut être attribué aux flots d’instructions ou aux flots de
données. Le flot d’instructions est une suite d’instructions issues d’une partie contrôle
9
Fig. 1.2 – Classification de Flynn
en direction d’un ou plusieurs processeurs. Un flot de données est une suite de données
venant d’une zone mémoire en direction d’un processeur ou venant d’un processeur en
direction d’une zone mémoire.
La classification des architectures parallèles la plus utilisée est la classification donnée
par Flynn [Fly66]. Cette classification a pour critère de sélection les modes de contrôle
effectuées par les différents processeurs. Cette classification comprend 4 classes d’architectures (Figure 1.2) :
– Machine SISD (Single Instruction Single Data Stream) ou Machine de Von Neumann : C’est le cas des ordinateurs séquentiels. Un ordinateur de ce type peut
avoir plusieurs unités fonctionnelles de traitement qui sont dirigées par une seule
unité de contrôle ;
– Machine SIMD (Single Instruction Multiple Data Stream) : chaque processeur exécute simultanément la même instruction sur plusieurs données différentes. Ce type
d’architecture comporte des processeurs multiples et un réseau d’interconnexion
servant pour la communication processeur à processeur ou processeur à mémoire ;
– Machine MISD (Multiple Instruction Single Data Stream) : chaque processeur
peut exécuter plusieurs instructions sur un même ensemble de données. Ce type
d’architecture correspond aux machines pipeline ;
– Machine MIMD (Multiple Instruction Multiple Data Stream) : chaque processeur
suit son propre flot d’instructions et traite une donnée propre. A l’inverse des
machines SIMD, les machines MIMD sont asynchrones : chaque processeur évolue indépendamment des autres et peut effectuer des opérations différentes sur
des données différentes au même instant. La communication de données ou des
résultats entre les processeurs de fait à travers le réseau de communication.
10
Mémoire partagée
Réseau d'interconnexion
Réseau d'interconnexion
Processeurs
Mémoires
Processeurs
Mémoires caches
Fig. 1.4 – Un réseau de machines à mémoire distribuée
Fig. 1.3 – Un réseau de machines à mémoire partagée
1.3
Distribution ou partage de la mémoire
Du point de vue organisation de la mémoire, il existe essentiellement deux types
de machines, les machines à mémoire partagée et les machines à mémoire distribuée
constituées d’un ou plusieurs processeurs, d’un ou plusieurs bancs mémoire et d’un réseau
d’interconnexion. Ces deux types peuvent être combinés pour aboutir à un troisième type
qui est la machine à mémoire virtuelle partagée.
– Machine à mémoire partagée (shared memory SM) : la mémoire est partagée par
tous les processeurs et donc tous les processeurs y ont accès. Dans ce type de
machine le réseau d’interconnexion relie les processeurs à l’ensemble des bancs
mémoire (voir Figure 1.3). Chaque processeur a accès à toute la mémoire, il s’agit
alors d’un espace d’adressage global. L’inconvénient de la mémoire partagée réside
dans la nécessité d’une programmation très délicate afin d’éviter les conflits d’accès
à un même emplacement mémoire ;
– Machine à mémoire distribuée (distributed memory DM) : chaque processeur à sa
propre mémoire qui est locale. Contrairement aux machines SM, le réseau d’interconnexion ne relie pas les processeurs à l’ensemble des bancs mémoire mais relie
les processeurs entre eux (Figure 1.4). L’adressage global n’est plus valable dans
ce cas. La communication entre les processeurs se fait typiquement par l’envoi des
messages ;
– Machine à mémoire virtuelle partagée (shared virtual memory SVM) : entre les
machines à mémoire partagée assurant un adressage global mais demandant une
programmation délicate et les machines à mémoire distribuée plus simples à programmer mais n’assurant pas l’adressage global, il existe les machines à mémoire
virtuelle partagée qui combinent les deux mémoires SM et DM. Dans ce type de
machine la mémoire est distribuée physiquement mais chaque processeur a un accès à la mémoire des autres processeurs par l’intermédiaire d’un logiciel qui assure
11
Fig. 1.5 – Classification unifiée des ordinateurs parallèles
ce partage de manière transparente.
1.4
Classification unifiée réelle des architectures
De nombreux auteurs [Tan91, Akl88] ont essayé de préciser la classification de Flynn
[Fly66]. Certains ont essayé de classifier les types d’architectures avec les machines actuelles [GRS92], d’autres en se basant sur ces différentes classifications ont déduit une
classification de machines unifiées actuelles [Deg92, GUD96, CT93, CS99, Tan05]. La
classification des architectures réelles peut se résumer comme sur la Figure 1.5 et nous
allons commenter cette classification dans la suite de cette section.
1.4.1
Les machines MIMD
Les machines MIMD ont plusieurs avantages par rapport aux machines SIMD.
– Elles ont un parallélisme plus fort que les machines SIMD,
– Elles peuvent exécuter plusieurs programmes ou des parties d’un programme sur
plusieurs processeurs.
Du point de vue mémoire et architectures actuelles, les machines MIMD peuvent se
diviser en trois catégories.
1.4.1.1
MIMD à mémoire globale physiquement partagée ou multiprocesseurs
Ces ordinateurs sont caractérisés par le fait que les processeurs ne possèdent pas
de mémoire locale. La mémoire globale est partagée entre les processeurs et tout accès
à cette mémoire est effectué à travers le réseau d’interconnexion. On parle alors d’une
12
mémoire physiquement centralisée (Figure 1.6) où les processeurs ont le même espace
d’adressage et peuvent donc lire et écrire dans la mémoire partagée. Les multiprocesseurs
sont faciles à programmer puisque les processeurs peuvent communiquer par simple
lecture ou écriture mémoire. Un de leurs inconvénients est qu’ils sont très coûteux en
prix à cause de la complexité de la mémoire partagée. Les multiprocesseurs sont divisés
en trois types selon l’implémentation de la mémoire :
– UMA (Uniform Memory Access) : les processeurs ont un accès uniforme à la mémoire,
– NUMA (Non Uniform memory access) : les processeurs ont un accès non uniforme
à la mémoire,
– COMA (Cache only Memory access) : les processeurs accèdent à la mémoire à
travers un cache.
Le lecteur trouvera plus de détails sur les types d’implémentation mémoire dans
[Tan05]. Pour ce type d’architectures, notons par exemple : SGI Cray (calculateur
T3D,T3E, T90, SV1), Compaq DEC (serveurs multiprocesseurs Pentium, Alpha) et
IBM (serveurs multiprocesseurs Pentium, PowerPC, PowerIII).
Fig. 1.6 – Mémoire physiquement centralisée
1.4.1.2
Fig. 1.7 – Mémoire physiquement distribuée
MIMD à mémoire distribuée ou multi-ordinateurs
Chaque processeur dispose de sa propre mémoire privée, qu’il est le seul à pouvoir consulter. L’espace d’adressage est donc physiquement distribué. A la différence
des multiprocesseurs, les multi-ordinateurs ne peuvent pas communiquer entre eux par
simple lecture ou écriture, la communication ou le partage de données entre les processeurs se fait à travers le transfert de messages via le réseau d’interconnexion. Les
multi-ordinateurs sont alors plus difficiles à programmer que les multiprocesseurs. Cependant, ils sont moins coûteux à construire. Ce type de machines peut se diviser en
deux catégories :
– MPP ou processeurs massivement parallèles : ce type de machines correspond à
des superordinateurs très coûteux (plusieurs millions d’euros). Ils sont caractérisés
13
par un réseau d’interconnexion ayant une très haute performance accélérant la
circulation des informations cas du transfert de messages. Ils sont utilisés pour
des applications spécifiques. Ils sont par exemple utilisés pour des gros calculs
scientifiques, industriels etc...
– COW (cluster of workstations) ou grappes de stations de travail : ils ont un réseau d’interconnexion du commerce qui est moins performant que celui des MPP.
Cependant, aujourd’hui à cause des réseaux d’interconnexion à haut débit, la différence entre les MPP et COW tend à se réduire.
Les Intel (calculateurs IPSC,PARAGON,ASCI RED,VIA) et IBM (calculateur SP)
sont des exemples des multi-ordinateurs. Le travail de cette mémoire est achevé sur
grappes de stations de travail composées des machines bi-processeurs Xeon hyperthreadés. La mémoire est donc distribuée et les processeurs communiquent à travers le transfert de messages.
1.4.1.3
MIMD à mémoire distribuée virtuellement partagée
Ce type de machines utilise une structure multi-ordinateurs et utilise le système
d’exploitation pour générer une mémoire virtuelle partagée. Chaque processeur dispose
d’une partie de la mémoire même si l’intégralité de la mémoire est accessible par tous
les processeurs. La mémoire est donc distribuée mais l’espace d’adressage est partagé ;
on parle alors d’une mémoire physiquement distribuée (voir la Figure 1.7).
1.4.2
Les machines SIMD
En 1966, un premier projet [BBK+ 68] concernant les machines parallèles et spécifiquement la première machines SIMD (ILLIAC IV) a été lancée. Les machines SIMD
n’exploitent qu’une seule forme de parallélisme, le parallélisme de données. Dans ce modèle, la même opération est appliquée sur une grande quantité de données. Ce modèle est
aussi caractérisé par son fonctionnement fortement synchrone ; chaque instruction doit
être complétée avant de commencer la suivante. Les architecture SIMD utilisent un grand
nombre (plusieurs dizaines de milliers) de processeurs élémentaires identiques. Ils sont
donc caractérisés par un très grand nombre d’unités de traitement simple. Par contre
l’unité de contrôle, permettant de lancer des commandes est centralisée. La mémoire
physique est distribuée et la communication entre les machines se fait à travers le réseau d’interconnexion. Parmi les machines SIMD citons, TMC (calculateurs Connection
Machine) et Intel (Pentium MMX et SSE).
Certaines classifications ont divisé les machines SIMD en deux catégories, les SIMD
à mémoire distribuée (SIMD-DM) et les SIMD à mémoire partagée (SIMD-SM). Dans ce
type de classifications, les SIMD-SM sont les machines vectorielles mono-processeurs, un
contrôle et des données centralisés, et réalisant des opérations vectorielles. Les opérations
sont réalisées d’une manière séquentielle en mode de fonctionnement pipeline (plus de
détails se trouvent dans [GUD96]).
1.5
14
Parallélisme de données et du contrôle
Le parallélisme peut être divisé en deux catégories : le parallélisme de données et le
parallélisme du contrôle. Le parallélisme de données distribue les données entre les processeurs et chaque processeur traite une partie des données. Cela est très efficace surtout
quand la quantité de données à traiter n’entre pas dans la mémoire d’un seul processeur
nécessitant ainsi la division des données (machines mémoire distribuée) pour pouvoir les
traiter. Le parallélisme du contrôle consiste à distribuer les tâches ou le travail séquentiel
en plusieurs parties qui sont réparties entre les processeurs. Il faut noter que ces deux
types de parallélisme sont très fins et demandent une distribution délicate des tâches
ou des données. Dans le cas de la distribution du contrôle, des coopérations liées à une
certaine dépendance entre les tâches sont demandées. Cela provient du fait que certaines
tâches ne peuvent pas s’exécuter avant que d’autres ne soient finies puisque leur exécution est dépendante de celles-ci. Il existe aussi le cas où des échanges d’informations entre
différentes tâches, même si elles sont indépendantes, sont nécessaires car la poursuite du
calcul requiert une mise à jour de certains résultats localisés sur d’autres processeurs.
La distribution de données, elle aussi, nécessite des échanges d’information si les données sont interdépendantes. Dans le cas d’une mémoire distribuée, il faut trouver une
stratégie de division de données minimisant le plus les communications et évitant ainsi
une perte de performance dans la parallélisation.
1.6
Critère d’évaluation
Quand un algorithme est parallélisé, l’idéal serait d’obtenir un temps de calcul divisé
par le nombre de processeurs, or ce n’est pas toujours le cas. En effet plusieurs paramètres
interviennent dans le cas d’une parallélisation aboutissant à une certaine perte dans les
performances. En général deux termes sont mesurés dans une parallélisation, l’efficacité
et l’accélération.
1.6.1
Efficacité
L’efficacité d’un algorithme est donnée par l’équation suivante :
Efficacité =
T seq
T par × n
où :
– T seq : le temps séquentiel de l’algorithme ;
– T par = max(T par(i)), i ∈ [1 . . . n] où i est le ième processeur et T par(i) le temps
en parallèle du processeur i ;
– n : nombre de processeurs.
L’efficacité maximale d’un algorithme est alors 1.
1.6.2
15
Accélération
L’accélération d’un algorithme est très similaire à celle de l’efficacité. Elle est définie
par l’équation suivante :
Accélération =
T seq
T par
où :
– T seq : le temps séquentiel de l’algorithme,
– T par =max(T par(i)), i ∈ [1 . . . n] où i est le ième processeur et T par(i) le temps
en parallèle du processeur i.
1.7
1.7.1
Multi-ordinateurs et Communication
Propriétés des réseaux d’interconnexion
Les caractéristiques des réseaux d’interconnexion des machines à mémoire partagée
(SM) et ceux à mémoire distribuée (DM) sont très différentes. Les machines SM nécessitent une bande passante (débit, quantité d’information acheminée par unité de temps)
plus grande. Cela vient du fait que ce type de machines achemine une quantité de données plus grande pour alimenter les processeurs. Concernant la latence (le temps mis par
le réseau pour réaliser le service demandé) elle doit être plus petite pour les machines
SM pour pouvoir garantir des communications rapides. Enfin le réseau d’une machine
SM a un adressage global et nécessite alors un acheminement d’information entre le bus
de données d’un processeur et un banc mémoire. De nombreuses études ont été faites
concernant les réseaux d’interconnexion [Lei91, dR94, GUD96, CT93]. Dans les machines
DM, les réseaux d’interconnexion sont appelés topologies et les processeurs reliés par ce
réseau sont les noeuds du réseau. Notons quelques définitions et notations permettant
de caractériser les réseaux d’interconnexion :
– Le degré d’un noeud : le degré d’un noeuds est égal au nombre de ses arêtes
adjacentes ;
– L’excentricité : l’excentricité d’un sommet est la plus grande distance de ce sommet
à un sommet quelconque du graphe ;
– Le diamètre : le diamètre D est défini comme le maximum des excentricités des
sommets du graphe. Il doit être faible pour permettre des communications efficaces ;
– Les sous-topologies : il est préférable qu’elles soient simples (anneaux et tores) ;
– Régularité : la régularité du réseau offre un avantage au programmeur lui facilitant
la compréhension du réseau et lui permettant ainsi de profiter de sa structure.
La topologie la plus simple est la topologie en réseau linéaire, suivie de la topologie
en réseau d’anneau. Dans un réseau linéaire, les noeuds ont un ordre croissant de 0 à
n − 1, n étant le nombre de noeuds ; chaque noeud possède deux voisins à l’exception du
premier et du dernier qui n’en ont qu’un. Dans un anneau tous les noeuds possèdent deux
16
Fig. 1.8 – Différentes topologies représentant respectivement, un réseau linéaire, un anneau de six processeurs, une grille 2D 4 × 5 et une grille torique 4 × 5
Fig. 1.9 – Hypercube de dimension 0, 1, 2 et 3 respectivement
voisins. On trouve aussi la structure de grille où chaque processeur a quatre voisins à
l’exception des processeurs situés dans les première et dernière lignes et ceux des première
et dernière colonnes. La grille torique est similaire à la grille mais les processeurs des
premières et dernières lignes et ceux des premières et dernières colonnes sont reliés. La
Figure 1.8 montre une illustration de ces différentes topologies. Une topologie ayant des
communications très efficaces est l’hypercube. L’hypercube de degré n est un réseau à 2n
noeuds où chaque noeud a exactement n voisins. La Figure 1.9 montre un exemple d’un
hypercube de degré 0, 1, 2 et 3. La topologie de l’hypercube possède un inconvénient : son
degré n’est pas borné, empêchant la réalisation de la machine physique. Il existe encore
d’autres topologies citons, le cube connecté en cycles de dimension n qui consiste à relier
un hypercube de chemins n et des anneaux de dimension n. Son degré est 3 (Figure 1.10).
Citons également la topologie en arbre binaire constituée d’un arbre de 2n − 1 sommets,
où tous les sommets non terminaux ont exactement deux fils (Figure 1.11) ainsi que les
réseaux de Bruijn [CT93] et les réseaux Star et Pancake [CNR92].
1.7.2
Les modèles de communication
Les machines à mémoire distribuée ont plusieurs formes de communications. On peut
distinguer les deux modes synchrone et asynchrone ainsi que les modes bloquant et non
Fig. 1.10 – Un cube connecté de dimension trois
17
Fig. 1.11 – Une arbre binaire
bloquant.
1.7.2.1
Les modes synchrone et asynchrone
Le mode synchrone peut être vu comme un mode de communication par rendez-vous.
L’envoi et la réception d’un message se font en même temps. Ce mode a pour avantage
la sûreté de la réception du message. Ce mode possède néanmoins un inconvénient : le
rendez-vous engendre parfois de longs temps d’attente.
Le mode asynchrone n’a pas un point de rendez-vous, les envois et les réceptions des
messages ne se passent pas en même temps mais se font à des instants quelconques.
1.7.2.2
Les modes bloquant et non bloquant
Ces deux modes font partie du mode de communication asynchrone. Dans le mode
bloquant, l’envoi d’un message se termine quand le message est envoyé (cela n’est pas
une garantie qu’il est bien reçu par le destinataire) et la réception se termine quand les
message est reçu. Le mode non bloquant tente de diminuer le temps d’attente en offrant
la possibilité de lancer des communications, des envois et des réceptions sans devoir
attendre qu’elles soient réalisées. Ce mode consiste à demander à une couche logicielle
d’effectuer l’envoi et la réception d’un message quand cela est possible. Il faut noter
que dans cette mémoire, les deux modes bloquants et non bloquants sont utilisés pour
les communications entre les noeuds. Le choix du mode dépend de la stratégie de la
parallélisation ainsi que le nombre de noeuds entrant en communication.
1.7.3
Logiciel de communication pour les multi-ordinateurs
Les architectures qui communiquent avec des messages sont connues depuis plusieurs années et des efforts ont été menés, pour l’amélioration des performances de ces
communications. Ces efforts ont permis récemment la portabilité du code source permettant aux programmeurs le transport du code de n’importe quelle architecture à une
autre. L’interface la plus répandue pour la communication entre les processeurs a été la
machine virtuelle parallèle ou PVM (Parallel Virtual Machine) [GBD+ 94]. PVM a été
18
remplacée par MPI (Message passing interface) [WD96] car MPI a montré plus d’avantages. Les fondateurs de PVM reprochaient à MPI de ne pas avoir une structure rigide et
vantaient la simplicité d’utilisation de PVM. MPI l’a emporté sur PVM car elle permet
plus d’opérations et contient une plus grande variété de routines. Une étude a été établie
pour la comparaison des deux librairies [GL97, GL02]. Notons que les deux interfaces
PVM et MPI assurent toutes les deux la portabilité du code.
MPI est apparue entre les années 1992 et 1994 grâce aux efforts de plusieurs groupes
comprenant des organisations, des groupes de travail et des chercheurs des Etat-Unis
et d’Europe. La version d’origine de MPI s’appelle MPI-1. Cette version a été étendue
en 1994 vers une version plus riche appelée MPI-2. MPI est le premier standard pour
la programmation des processeurs. Il s’agit d’une librairie composée des fonctions et de
macros qui peuvent être utilisées avec des programmes en langage Fortran, C et C++.
Elle offre plusieurs avantages :
– Permet la portabilité du code source ;
– Permet une implémentation efficace à travers plusieurs architectures et supporte
les architectures hétérogènes ;
– Assure une bonne fonctionnalité puisqu’elle contient plus de 115 routines ;
– Disponibilité : plusieurs implémentations sont accessibles ;
– Utilisable avec le C et le Fortran ;
– Permet des communications efficaces car elle évite les copies mémoire ;
– Facile à utiliser [Pac95] ;
– Efficace pour les systèmes à mémoire distribuée ;
– Définit une interface qui peut être implémentée sur différentes plate-formes sans
modifications des communications du logiciel.
Plusieurs références présentent les caractéristiques de MPI ainsi que ses différentes
fonctionnalités et routines [GLDS96, Pac96, GHLL+ 98, aSOaDWD98, GLS99]. MPI est
caractérisée par le type de ses communications (points à points, collectives, bloquantes
et non bloquantes), le type des données, les topologies virtuelles, les communicateurs et
les groupes.
1.7.3.1
Communications offertes par MPI
MPI offre deux modes essentiels de communication, les communications point à
point qui concernent exactement deux processeurs et les communications collectives qui
concerne chacun des processeurs d’un groupe [MMM+ ].
1. Communications point à point :
Il existe 4 modes de communications proposées par MPI : standard, synchrone,
buffered et ready (prêt). Dans ces 4 modes l’importance se situe dans la réception
du message. Les détails de chaque mode peuvent se décrire comme suit.
– Mode standard : l’envoi se termine quand le message est envoyé. Cela ne garantit
pas la réception du message, le message est peut être reçu ou non. Ce mode peut
être utilisé comme synchrone ou buffered ;
19
– Mode synchrone : le processeur qui envoie doit être sûr que le message a bien été
reçu. Généralement le processeur qui reçoit le message doit prévenir le processeur
qui a envoyé le message que celui-ci a bien été reçu. Dans ce cas, l’envoi est
considéré comme terminé ;
– Mode buffered : garantit la copie du message au système buffer. La réception du
message n’est pas garantie. L’inconvénient de ce mode est qu’il faut allouer des
espaces pour le buffer ;
– Mode ready : comme le mode buffer, le mode ready termine directement et il
n’attend pas la réception du message. Mais si le message n’est pas reçu, un
drapeau d’erreur sera levé.
Notons que chacun de ces modes existe sous la forme avec et sans blocage.
2. Communications Collectives :
MPI supporte les communication collectives. Elle contient un grand nombre
de fonctions pour la distribution et la redistribution des données, le regroupement
des données et les opérations globales sur les données (multiplication, soustraction,
somme etc). Ces communications collectives facilitent le travail et évitent de faire
des boucles pour les envois et les réceptions dans les opérations collectives quand un
processeur communique avec tous les autres ou tous les processeurs communiquent
entre eux. Parmi les opérations collectives les plus utilisées citons le broadcast où
un processeur envoie à tous les autres, le scatter où un processeur distribue des
donnés aux autres, le gather où les données sont collectées de plusieurs processeurs
à un seul, le allgather où les données de tous les processeurs sont collectées sur tous
les processeurs (Figure 1.12). Parmi les communications collectives importantes, il
y a aussi le reduce qui consiste à calculer un résultat utilisant des données de tous
les processeurs comme le maximum, le minimum et la somme (Figure 1.13).
Fig. 1.12 – Communications collectives
Fig. 1.13 – Le reduce, additionnant des données de
tous les processeurs
20
Fig. 1.14 – Une topologie virtuelle de 16 processeurs
1.7.3.2
Le type des données
MPI prend en considération de nombreux types de données comme les chaînes de
caractères, les entiers normaux, longs et courts, les nombres flottants, les doubles etc...
1.7.3.3
Topologie
L’utilisation des communications et de la topologie différencie MPI des autres systèmes utilisant le transfert de messages. MPI permet le classement des processeurs en ordre
topologique. La topologie est un mécanisme qui permet de nommer les processeurs d’un
groupe. Elle permet d’optimiser les communications entre les processeurs ; les processeurs
sont nommés de manière à ce que chaque processeur communique avec les processeurs les
plus proches. Les topologies offertes par MPI sont la topologie cartésienne et la topologie
des graphes. La Figure 1.14 montre une topologie cartésienne virtuelle avec les lignes qui
indiquent la communication entre les voisins. Pour chaque processeur, le numéro (rank)
est indiqué ainsi que les coordonnées du processeur sur la grille.
1.7.3.4
Groupe et Communicateur
MPI permet l’organisation des processeurs en groupes permettant la communication
entre les processeurs d’un même groupe ou les processeurs appartenant à des groupes
différents grâce au communicateur. Le communicateur est un objet opaque qui détermine l’environnement de communication où les communications vont s’effectuer. Chaque
21
Fig. 1.15 – Division d’un groupe en deux groupes chacun ayant son propre intracommunicateur
communicateur contient un groupe de processeurs. Il existe deux types de communicateurs : l’intracommunicateur permettant la communication au sein d’un même groupe,
et l’intercommunicateur permettant la communication entre deux ou plusieurs groupes
différents. Les communicateurs sont dynamiques, ils peuvent être créés et détruits au
cours d’un programme. Chaque communicateur a ses attributs qui sont fixés aux moment
de sa création. Normalement dans un programme MPI n’ayant qu’un seul groupe de processeurs, un seul communicateur est nécessaire. Il s’agit de MPI_COMM_World, qui est
défini par défaut, permettant la communication entre tous les processeurs. Dans certaines
applications, une distribution des tâches en groupes indépendants est souhaitable. Dans
ce cas la création des différents groupes ayant chacun son propre intracommunicateur
facilite la communication entre les processeurs (Figure 1.15).
1.8
Conclusion
Les architectures parallèles ont plusieurs caractéristiques importantes et dont il faut
tenir compte lors de la parallélisation d’un algorithme. Pour une application donnée,
il faut trouver la meilleure manière de décomposer un algorithme et il faut prendre en
considération le type de machines à disposition (multi-ordinateurs, multiprocesseurs...)
afin d’obtenir une bonne efficacité et une bonne performance.
Dans ce chapitre, nous avons présenté différentes architectures parallèles ayant chacune ses caractéristiques. Le travail de mémoire porte sur le parallélisme d’une méthode
d’illumination globale par voxels. Il est mis en oeuvre sur un cluster utilisant l’interface
MPI pour le transfert des messages et la communication entre les noeuds et dont le
principe a été décrit dans ce chapitre. Néanmoins il est toujours envisageable d’utiliser
d’autres types d’architecture, comme les multiprocesseurs et de comparer l’influence de
l’architecture sur l’efficacité et l’accélération de l’algorithme parallèle.
22
Chapitre 2
Illumination globale, radiosité et
parallélisme
La synthèse d’images et l’infographie sont deux termes fortement liés ; le premier
génère les images par ordinateur et le deuxième transforme un modèle informatique en
une représentation graphique.
La synthèse d’images est la génération d’images par ordinateur. Les images de synthèse par ordinateur ont plusieurs applications. Péroche [Pér91] cite cinq domaines d’applications dans lesquelles interviennent les images de synthèse : la conception assistée
par ordinateur (CAO) qui comprend trois domaines la mécanique (automobile, aéronautique...), l’électronique (ordinateurs, lave-linge, téléviseurs ...), l’urbanisme et architecture (dessins des projets assistés par ordinateur...), la visualisation scientifique qui
inclut la modélisation moléculaire et la dynamique, le graphisme de communication qui
englobe les rapports d’activités et les plaquettes publicitaires des entreprises, l’audiovisuel comme les dessins animés les publicités et le cinéma et le domaine artistique
utilisant des plaquettes électroniques.
L’objectif d’une partie de la synthèse d’images est de créer des images aussi exactes
et réalistes que possible. Il existe deux champs essentiels qui jouent un rôle important
dans la synthèse d’images : la modélisation géométrique et la visualisation.
La modélisation géométrique consiste à décrire les modèles des objets qui constituent l’environnement. Ces objets peuvent être représentés d’une manière simple, par
des points, lignes ou triangles. Ils peuvent aussi se représenter mathématiquement par
des surfaces implicites (plan, sphère, cylindre...) plus difficiles à manipuler mais paramétrables ; ces surfaces exigent le transfert du modèle mathématique en une représentation
visuel ou graphique pour la visualisation du modèle [SK01]. Une représentation, permettant de représenter des objets plus complexes, est aussi possible à l’aide des surfaces
paramétrées (Béziers, B-Splines, espaces NURBS). Ces surfaces paramétrées sont basées
sur un calcul polynomial [Mal02a].
La visualisation est très importante en synthèse d’images. Elle nécessite le respect
des caractéristiques physiques des matériaux et de l’environnement et des phénomènes
de transport de la lumière pour une simulation correcte de la distribution de lumière.
23
Chapitre 2. Illumination globale, radiosité et parallélisme
24
La visualisation demande aussi une compréhension de la perception visuelle du système
visuel humain. La perception humaine peut être associée directement à la réalité virtuelle,
qui est une simulation informatique interactive dans laquelle le graphisme est utilisé afin
de pouvoir plonger l’utilisateur dans l’environnement lui donnant ainsi l’impression qu’il
est présent dans un monde virtuel. La visualisation doit tenir compte des effets statiques
comme la forme, la couleur, les textures et la position des objets et doit tenir compte
aussi des effets dynamiques qui ont une influence directe sur les effets visuel comme le
changement de la position des objets ou de la caméra. Plusieurs travaux ont été menés
dans la littérature pour la simulation de l’éclairement et la génération des images de
synthèse réalistes [Tel93, Dam01, DHS04].
Lorsque le réalisme est de rigueur, on parle alors de rendu réaliste (realistic rendering). Le rendu réaliste nécessite la résolution du problème d’illumination avec le plus de
précision possible en respectant les caractéristiques physiques de l’environnement. Parmi
les premiers modèles de rendu, citons les modèles de Phong et Gouraud [Pho75, Gou71].
Ces modèles ont pris en compte l’illumination directe mais ils ont ignorés l’illumination
indirecte causée par les phénomènes d’inter-réflexions entre les surfaces et ne fournissent
pas une distribution réelle et précise de la lumière. D’autres méthodes ont été proposées
pour une simulation plus précise de la lumière et le calcul de l’illumination. Il existe par
exemple les méthodes de lancer de rayons comme le ray tracing et le photon mapping. Il
y aussi les méthodes de radiosité qui ont pris en compte des phénomènes des réflexions
et inter-réflexions entre les surfaces. La radiosité a été l’une des premières méthodes
les plus avancées pour la simulation d’illumination globale ; elle a été considérée comme
un outil important pour le calcul des inter-réflexions de la lumière entre des surfaces
diffuses, offrant une simulation précise de l’illumination dans une scène. La radiosité a
été dépassée par les méthodes à base de rayons comme le photon mapping et le ray
tracing, notamment parce qu’elle ne gère pas bien les BRDF (Bidirectional Reflectance
Distribution Function).
La plupart des algorithmes de radiosité souffrent de problèmes de complexité en
mémoire et en temps de calcul, ce qui a restreint leur diffusion dans les applications du
commerce et de l’industrie. Le parallélisme permet d’offrir une solution pour ce genre
de problèmes grâce à la capacité des machines parallèles qui permettent de diminuer la
complexité en temps de calcul et en mémoire dans le calcul de radiosité.
Dans ce chapitre, l’illumination globale est expliquée ; les méthodes de calcul d’illumination globale par lancer de rayons ou par radiosité sont aussi décrites. Ensuite,
la radiosité est définie avec ses équations d’éclairement et les différentes méthodes de
résolution du système d’équations sont expliquées. Finalement les améliorations des algorithmes de radiosité ainsi que l’état de l’art des méthodes utilisées pour paralléliser
les algorithmes de radiosité sont exposés.
Ce chapitre insiste plus sur la radiosité que sur d’autres méthodes de calcul d’illumination globale. Cela est en effet dû au fait que l’algorithme d’illumination globale que
l’on cherche à paralléliser dans ce travail est basée sur l’équation de radiosité qui est
discrétisée en voxels et résolue par un algorithme spécial, basé sur des notions de droites
discrètes pour la gestion de la visibilité (voir Chapitre 3). Cet algorithme d’illumination
25
a été étendu du cas diffus idéal au cas BRDF [CM07] par Chatelier et Malgouyres. Ces
extensions ne sont pas parallélisées dans ce travail mais feront l’objet des perspectives
envisagées.
2.1
Réflexion et réfraction
Quand un rayon lumineux se propage dans un environnement et arrive à la surface
d’un second milieu, ce rayon subit des phénomènes dit de réflexion et de réfraction.
Une partie de la lumière est réfléchie et l’autre partie pénètre dans le second milieu
(réfraction).
En physique, un milieu se caractérise par un indice de réfraction, qui caractérise la
vitesse de propagation de la radiation dans ce milieu. La proportion de la lumière réfléchie
dépend des indices de réfractions des deux milieux. L’angle d’incidence est l’angle formé
par le rayon incident et la normale à la surface au point d’incidence. D’après les lois de
réflexion, l’angle de réflexion est égal à l’angle d’incidence (Figure. 2.1 (a)). Concernant
le rayon réfracté il est déterminé par les lois de la réfraction de Snell et Descartes. Le
rayon incident et rayon réfracté se situe de part et d’autre du plan tangent et l’angle de
réfraction est calculé à partir de l’angle d’incidence et les indices de réfraction des deux
milieux. La Figure. 2.1 (b) montre l’angle de réfraction calculer à partir des indices de
réfraction des deux milieux et de l’angle d’incidence.
Fig. 2.1 – Le modèle spéculaire de Phong
2.2
Modèles d’éclairement
Dans un environnement donné, la lumière en provenance d’une source lumineuse et
qui interagit avec une surface subit des phénomènes de réflexion. Les phénomènes de
26
réflexion sont des phénomènes fortement liés aux caractéristiques des matériaux (type
de surface, propriétés physique et caractéristiques optiques) de la surface avec laquelle la
lumière interagit [Gou05]. Par exemple pour les matériaux conducteurs, laissant très peu
d’énergie les pénétrer, une surface lisse (miroir) est idéalement spéculaire (Section 2.2.2)
et une surface plus rugueuse est spéculaire mais pas idéalement spéculaire. Pour les
matériaux diélectrique ou peu conducteur, la lumière incidente est absorbée par la surface
pour être ensuite réfléchi sous forme de lumière diffuse (Section 2.2.1) émise dans toutes
les directions. On peut distinguer essentiellement trois modèles d’éclairement le modèle
diffus, le modèle spéculaire et la BRDF, qui sont expliqués ci-dessous.
2.2.1
Le modèle diffus idéal ou modèle Lambertien
Le modèle Lambertien est le modèle le plus utilisé et le plus simple pour décrire le
phénomène de réflexion. Dans ce modèle, l’énergie ré-émise est la même dans toutes les
directions. Cette énergie lumineuse dépend du rayon incident, elle est maximale pour
un éclairage zénithal et nule pour un éclairage rasant. La Figure 2.2 illustre le modèle
Lambertien qui s’exprime sous la forme :
Id = Ii × Kdiff × cos θ
où :
– Id : intensité diffuse ;
– Ii : intensité incidente ;
– Kdiff : coefficient diffus, constante dépendant du matériau (coefficient de réflexion
spéculaire) ;
– θ : angle d’incidence de la lumière calculé par rapport au vecteur normal à la
surface.
Fig. 2.2 – Le modèle Lambertien
2.2.2
27
Le modèle spéculaire
Le modèle spéculaire prend en compte la position de l’observateur dans le phénomène
de réflexion contrairement au modèle diffus. On peut distinguer deux cas : le cas spéculaire idéal (miroir) où la lumière est réfléchie dans la direction symétrique par rapport à
la normale ; le deuxième cas est le cas spéculaire classique ou le modèle de Phong [Pho75]
où la lumière ré-émise est plus intense autour du rayon réfléchi idéal (Figure 2.3). Ce
dernier modèle s’exprime comme suit :
IS = Ii × KS × cosn θ
où :
–
–
–
–
–
IS : intensité spéculaire (intensité de lumière sortante) ;
Ii : intensité incidente ;
KS : constante dépendant du matériau (coefficient de réflexion spéculaire) ;
θ : angle entre la direction de sortie et le rayon réfléchi idéal ;
n :puissance qui traduit la concentration de la lumière spéculaire réfléchie du matériau.
Fig. 2.3 – Le modèle spéculaire de Phong
2.2.3
BRDF : Bidirectional Reflectance Distribution Function
Ce modèle permet de quantifier le rapport entre l’énergie incidente et l’énergie sortante au point d’impact d’un rayon suivant les propriétés du matériau. De nombreuses
représentations des BRDFs ont été proposées dans la littérature [War92, KM99, AS00,
CM07]. La BRDF peut être vue comme une fonction à quatre paramètres (θin , φin , θout ,
φout ), les coordonnées sphériques, permettant de quantifier le flux d’énergie sortant dans
une direction donnée (θout , φout ) par rapport à un flux incident dans une direction donnée
(θin , φin ). La Figure 2.4 montre une représentation d’une BRDF.
28
Fig. 2.4 – Une BRDF et ses quatre paramètres (θin , φin , θout , φout )
2.2.4
Angle solide, radiance et irradiance
Une définition exacte de l’échange d’énergie radiante nécessite la notion d’angle solide. L’angle solide est utilisé pour mesurer la portion de l’espace occupé par un objet
qui est vue à partir d’un point.
L’angle solide d’un objet vue à partir d’un point est l’aire de la projection de cet objet
sur la sphère unité centrée au point. Si la surface est très petite de surface (∆A), l’angle
solide est approximé à la projection au plan perpendiculaire à la direction d’origine, au
lieu de la sphère (Figure 2.5), et l’équation de l’angle solide est alors :
∆A ≈
∆A cos θ
r2
où : ∆A cos θ : surface de la projection.
r : distance à l’origine
Fig. 2.5 – Angle solide pour une petite surface [SP94]
29
La radiance, dénotée par L, est une mesure locale de la densité de flux d’énergie. Elle
représente la quantité totale d’énergie émanant d’un point dans une direction donnée.
C’est une puissance par unité de surface et par unité d’angle solide. Elle est utilisée
pour décrire le transfert radiatif [SP94]. Elle s’exprime en watts par mètre carré et par
stéradian (W m−2 sr−1 ).
L’irradiance est l’intégration de l’intensité entrante. Elle représente la quantité d’énergie par unité de surface et s’exprime en watts par mètre carré (W m−2 ).
2.2.5
Illumination locale
Le terme illumination locale est un terme simplifié qui suppose que l’illumination d’un
point ou d’un élément de surface dépend de la propriété d’un élément de surface ainsi
que de la lumière incidente provenant des sources. Etant donnée uniquement une surface,
N la normale à cette surface et L la direction de la lumière incidente, la réflexion diffuse
peut être calculée en utilisant la loi Lambertienne (Section 2.2.1). Or l’illumination locale
est incapable de générer des images vraiment réalistes ; cela vient du fait que seule la
lumière en provenance directement des sources lumineuses est prise en considération. En
réalité, les surfaces reçoivent aussi de la lumière indirecte résultant des inter-réflexions
avec d’autres surfaces. Ce phénomène indirect n’est pas pris en compte par l’illumination
locale.
2.2.6
Illumination globale
La production des images de synthèse la plus réelle que possible, nécessite une précision de traitement des effets de la lumière. A la différence du modèle d’illumination
locale où la surface courante et la direction de la source lumineuse sont seulement pris en
considération pour calculer la lumière réfléchie, le modèle d’illumination globale prend
en considération les inter-réflexions de la lumière, et donc tous les objets de la scène.
Le modèle d’illumination globale permet alors la simulation d’une manière précise des
inter-réflexions et par conséquent des effets d’éclairement.
2.2.6.1
Equation d’illumination globale
L’équation d’illumination globale traduit l’équilibre énergétique d’une scène et s’exprime avec la radiance. Cette équation se décrit comme suit : l’émission d’un élément
est la somme de son émission propre et de la ré-émission de l’énergie qu’il reçoit. Etant
donné un point x, soit (θout , φout ) la direction sortante, la radiance L est alors l’inconnue :
Z
L(x, θout , φout ) = Le (x, θout , φout ) +
{z
} |
{z
}
|
radiance totale
radiance propre
ρbd (x, θin , φin , θout , φout )Li (x, θin , φin ) cos θin dω
|
{z
}
Ω
radiance émise
(2.1)
Les termes de cette équation sont :
–
–
–
–
–
–
–
–
–
–
30
x : point d’émission ;
L : radiance du point x ;
θin , φin : angles polaires dans un repère local à x, de la direction d’incidence ;
θin , φin : angles polaires dans un repère local à x, de la direction de sortie ;
Le : radiance d’émission propre à x, s’il appartient à une source lumineuse cette
fonction est connue ;
Li : radiance incidente en x, dépendante des radiances des autres points de la
scène ;
Ω : sphère d’intégration centrée en x ;
ρbd : la BRDF ; cette fonction est un ratio entre une radiance sortante et un flux
de radiance entrante. Elle est supposée connue en tout point x et pour toutes
directions ;
cos θin : terme traduisant l’unité de surface projetée ;
dω : intégrande angle solide.
2.3
Méthodes par lancer de rayons
L’illumination globale est un phénomène très étudié par les chercheurs dans le but
de pouvoir simuler d’une manière précise les échanges énergétiques et les réflexions.
L’ensemble des échanges énergétiques peut être calculé en utilisant un lancer de rayons.
Le lancer de rayons est très populaire car il permet de présenter des scènes 3D de
façon très réaliste. Il demeure le modèle de simulation d’illumination-réflexion idéal en
infographie.
2.3.1
Pixels et rayons
La résolution du problème de lancer de rayons est générer tous les rayons qui traversent les pixels de l’image et issus du centre de projection qui est le lieu de l’observateur.
Ceci permet le calcul de la moyenne des couleurs de tous les rayons traversant le pixel.
2.3.2
Modèle simple de lancer de rayons
Un modèle simple de lancer de rayons traite seulement l’interaction des points de la
surface avec les rayons provenant des sources lumineuses. Il traite seulement les rayons
provenant de l’illumination directe, c’est le cas de l’illumination locale. Or dans la réalité, il faut prendre en considération l’illumination globale car d’autres rayons lumineux
atteignent la surface à travers le phénomène de réflexion et réfraction.
2.3.3
Algorithmes par lancer de rayons
Le principe de lancer de rayons peut être appliqué pour le calcul de l’illumination
globale à travers le calcul de l’intersection de la lumière par un pixel d’une scène donnée.
31
Fig. 2.6 – Le rayon d’éclairement
Fig. 2.7 – Rayon réfléchi
Les algorithmes de lancer de rayons, en général, génèrent le chemin entre les sources
de lumière et les points de la scène pour lesquelles on cherche à calculer la valeur de
la radiance. Plusieurs algorithmes de lancer de rayons sont connus pour le calcul de
l’illumination [DBB03]. Dans ce cadre, deux approches essentielles de lancer de rayons
peuvent être utilisées : le lancer de rayons partant des sources lumineuses (light-tracing)
ou depuis la caméra (ray tracing). Ces deux approches peuvent être combinées pour
aboutir au bi-directional path-tracing.
2.3.3.1
Ray Tracing
Le ray tracing fut apparaître en 1980 par Whitted [Whi80] ; Whitted implémente
le premier modèle la plus répandu en rendu, utilisant la technique du ray tracing. En
physique, les points de départ de la lumière sont les sources lumineuses. La lumière des
sources arrive à l’observateur après avoir subi diverses réflexions et réfractions. Parmi les
rayons issus d’une source lumineuse, il y en a plusieurs qui n’arrivent pas à l’observateur
ce qui pousse à suivre les rayons à l’envers depuis l’observateur vers les sources lumineuses
évitant ainsi le traitement des rayons inutiles. C’est le principe du ray tracing qui consiste
à parcourir un rayon de l’arrière en prenant l’oeil ou la caméra comme point de départ
et suivant le rayon jusqu’au pixel de l’image pour déterminer l’objet de contact. La
couleur réfléchie à partir de la direction du rayon est premièrement calculée en calculant
la lumière incidente au point de contact.
32
Cependant pour un rayon donné, il ne faut pas seulement considérer l’illumination
directe des sources lumineuses, mais il est important de déterminer la totalité de la
lumière qui superpose ce rayon. Ces rayons lumineux peuvent être divisés en quatre
classes [Mal02a] :
– Les rayons primaires : issues directement de l’observateur ;
– Les rayons d’éclairement : provenant d’une source lumineuse vers la surface (Figure 2.6) ;
– Les rayons réflechis : provenant d’un phénomène de réflexion à travers l’objet
(Figure 2.7) ;
– Les rayons de transparence : provenant d’un phénomène de réfraction à travers un
objet qui dans ce cas est transparent ou partiellement transparent ; (Figure 2.1).
Ces rayons secondaires résultants des réflexions, réfractions et effets spéculaires permettent d’évaluer la lumière transportée à partir du rayon. Cela s’appelle ray tracing
récursive de Whitted [Whi80]. Ce ray tracing récursif permet le calcul des réflexions,
réfractions, or il est limité aux réflexions spéculaires idéales. Il a été amélioré par Cook
qui a étendu le ray tracing, permettant des meilleurs modèles de réflexion [CT82] et
utilisant un échantillonnage stochastique [CT86]. Le ray tracing est considéré comme la
forme la plus utilisée du ray shooting pour générer des images. Le ray shooting avait
beaucoup d’applications en infographie, ce qui a poussé les chercheurs à s’intéresser à accélérer le ray tracing. Plusieurs techniques pour accélérer le ray tracing ont été proposées
[Gla89, Shi02, SM03, FF97].
Malgré l’utilisation du ray tracing pour générer des images, il faut indiquer que
beaucoup d’algorithmes en illumination globale utilise parfois le ray tracing seulement
pour le calcul de visibilité. Le ray tracing peut être aussi utilisé dans d’autres applications
que l’infographie comme par exemple [AFF97].
De nos jours, les systèmes et logiciels exécutent rapidement le ray tracing. Aussi grâce
aux ordinateurs parallèles et à la capacité du calcul offerte par ceux ci, plusieurs travaux
de parallélisation du ray tracing ont été menés sur des multiprocesseurs [KH95, Muu,
PMS+ 99], sur des grappes de stations de travail [WSB01, Wal04] ou réalisés entièrement
en hardware [SWS02]. Toutes ces améliorations ont permi au ray tracing d’atteindre des
capacités temps réel.
2.3.3.2
Light tracing
Le light tracing peut être vue comme le dual du ray-tracing. Dans le ray-tracing, le
chemin optique est tracé de l’oeil ou la caméra vers les sources de lumière. L’idée du raytracing élémentaire est de ne calculer que des rayons utiles. Or ce tracé du ray-tracing
ne suit pas le vrai trajet de lumière. Le light tracing, lui suit le trajet de lumière. Le
chemin optique est alors tracé des sources lumineuses vers l’oeil ou la caméra.
En ray-tracing, à chaque point d’impact, on teste la présence ou non d’un éclairage
direct en vérifiant si les sources lumineuses sont visibles depuis ce point. Cela force la
découverte des sources lumineuses pour le rayon courant. En light-tracing, la même idée
est utilisée pour forcer la découverte de la caméra.
2.3.3.3
33
Bi-directional path-tracing
Le bi-directional path-tracing consiste à combiner ray-tracing et light-tracing pour
profiter des avantages des deux. Des rayons sont tracés depuis la caméra et depuis la
source. En connectant les chemins générés, il est possible de calculer la contribution des
deux dans le transport de la lumière. Le path-tracing a été développé par Lafortune
[LW94] et Veach [Vea94].
2.3.3.4
Instant Radiosity
L’instant radiosity a été introduite par Keller [Kel97]. Elle est différente des méthodes
de radiosité usuelles (voir Section 2.4), elle consiste à remplacer l’illumination indirecte
diffuse, provenance des autres surfaces autre que les sources lumineuses, dans une scène
par une illumination directe diffuse d’un ensemble de sources lumineuses ponctuelles. Des
particules sont tracées des sources de lumière (appelées aussi point de lumière virtuelle)
en se basant sur la méthode quasi-random work [Kel96]. Au moment où le rayon lumineux
rencontre un objet d’une surface, un point de lumière est rajouté au point de contact
permettant ainsi d’approximer la lumière réfléchie de cette partie. L’illumination directe
résultante de ces sources ponctuelles de lumière est alors cumulée. Des cartes graphiques
sont utilisées pour le calcul de l’illumination des sources ponctuelles. Cette approche
ressemble au bi-directional path-tracing or elle est plus rapide.
2.3.3.5
Photon Mapping
Le photon mapping (carte de photons) introduit dans [JC95b] et notamment étendu
dans [Jen95, JC95a, Jen96] est une technique de calcul d’illumination globale. Elle est
la plus utilisée à l’heure actuelle car elle est simple à implémenter et offre des temps
de calcul raisonnables tout en utilisant une consommation mémoire convenable. Cette
méthode fonctionne en deux passes. Une première passe consiste à construire les photon
maps et une deuxième passe de rendu.
Première passe
Le photon mapping se construit par émission des photons à partir des sources lumineuses. Ces photons sont propagés dans la scène et subissent des phénomènes de
réflexion, transmission ou absorption. Une Russian Roulette [AK90] est utilisée pour
déterminer si le photon est absorbé ou réfléchi. Quand les photons entrent en contact
avec des surfaces spéculaires, ils sont mémorisés dans une structure appelée photon mapping. Deux cartes de photons sont calculées, une carte de caustiques et une carte globale.
Les caustiques se forment quand la lumière est transmise ou réfléchie à partir des surfaces spéculaires avant d’arriver à une surface diffuse. Le photon mapping est efficace
pour le calcul des caustiques. En général, les caustiques se forment quand la lumière est
concentrée, demandant ainsi un nombre de photons limité.
34
Le photon map représente un paquet d’énergie arrivant à une surface. La densité du
photon permet alors l’estimation de l’irradiance. La radiance en un point peut alors
être calculée en multipliant l’irradiance par la BRDF de la surface.
Deuxième passe
Le deuxième passe est le calcul du rendu et alors la visualisation de la radiance
de chacun des points de l’image. L’utilisation du photon mapping demande un grand
nombre de photons pour une bonne visualisation d’une image de haute qualité. Une
solution possible est l’utilisation du photon mapping seulement pour les calculs qui sont
nécessaires et d’intégrer autres techniques (le ray tracing) pour le calcul de l’illumination directe. L’un des principes du photon mapping est le découpage de l’équation de
luminance ré-émise en un point en quatre contributions qui peuvent se résumer comme
suit :
– L’illumination directe : elle correspond à la lumière qui atteint un point donné
directement depuis les sources lumineuses. Cette illumination est calculée utilisant
le principe traditionnel du ray tracing proposé par Whitted [Whi80] ;
– L’illumination spéculaire : correspond aux effets de réflexions à travers des surfaces
spéculaires (miroir). Elle est calculée utilisant le principe du ray tracing ;
– Les caustiques : corresponds à la lumière qui atteint une surface en passant par
des réflexions spéculaire. Ils sont calculés utilisant le photon map ;
– L’illumination indirecte : correspond à la lumière quittant un point donné en passant par au moins une réflexion diffuse. Cette lumière est calculée utilisant le
photon map pour le calcul de la radiance.
2.3.3.6
Modèle Metropolis
Le modèle Metropolis de calcul d’illumination globale a été développé par Veach et
Guibas dans [VG97]. Ce modèle est basé sur la technique d’échantillonnage Metropolis
[MRR+ 53] appliquée sur les chemins optiques. Dans l’algorithme Metropolis, l’image est
calculée en échantillonnant les chemins correspondant au trajet de la lumière. Ce modèle
est caractérisé par les mutations qui s’appliquent aux chemins. Lors de la génération
d’une série de chemins, les mutations consistent à recoller ou supprimer des sommets
du chemin précédent. Ce modèle offre des avantages et apparaît efficace dans le calcul
des images des scènes contenant des chemins de lumière difficiles à calculer comme
des fortes illumination indirectes construites à partir d’un nombre de chemins optiques
limités. Dans ces cas, les mutations permettent un calcul non coûteux des chemins. Or
ce modèle reste compliqué du côté implémentation surtout quand le nombre de chemins
augmentent, nécessitant alors des précautions lors de l’application de l’algorithme.
2.3.3.7
Irradiance Caching
L’irradiance caching a été introduite dans [WRC88]. Cette technique est utilisée
pour accélérer le calcul de l’illumination indirecte, coûteuse en temps de calcul, dans
35
des scènes diffuses. La complexité en temps de calcul d’illumination indirecte vient du
fait qu’un grand nombre de rayons est nécessaire pour le calcul de l’irradiance. En effet
l’irradiance varie très lentement à travers les surfaces diffuses. L’irradiance caching part
de ce principe et suppose qu’il est suffisant de calculer l’irradiance a des endroits ou
points précis et de faire une interpolation pour calculer la valeur de l’irradiance pour les
autres points. Dans cette méthode, l’irradiance des points sélectionnés est cachée dans
une structure de donnée (octree). Pour les autres points, l’irradiance est interpolée à
partir des valeurs cachées.
2.4
Radiosité
La radiosité est définie comme la quantité totale d’énergie émise par un point de
surface, par unité de surface. Les premiers algorithmes de radiosité apparaissent en 1984
[GTGB84, NN85] dans le but de modéliser les interactions lumineuses entre les surfaces
diffuses. Ces algorithmes proviennent de l’application de la théorie de l’énergie radiative
au problème d’illumination globale [SH92]. La radiosité a un avantage par rapport au
ray tracing et c’est qu’elle est indépendante de la position de l’observateur, elle permet le
calcul d’une solution qui est indépendante de celui ci. Après les échanges d’énergies entre
les surfaces, si le point de vue de l’observateur change, un minimum de changement est
demandé en utilisant la radiosité. Cela n’est pas le cas avec le ray tracing qui calcul une
solution dépendante du point de vue de l’observateur. La radiosité utilise les principes
d’émission, de réflexion et d’inter-réflexion pour simuler les réflexions et inter-réflexions
de la lumière dans la scène pour arriver finalement à un équilibre et une convergence
vers la bonne solution de radiosité.
2.4.1
Equation de la radiosité
La radiosité représente la quantité totale d’énergie quittant une surface en un point
donné par unité de surface. La radiosité en un point x peut être décrite en fonction de
la radiance L(x, θ, φ), (θ et φ étant les angles polaires dans un repère local à x) sur la
sphère englobante ω par l’équation suivante :
Z
B(x) =
L(x, θ, φ) cos θdω
(2.2)
Ω
La radiosité constitue une solution pour un milieu diffus idéal ; pour ce genre de
milieu, l’équation (2.4.1) de radiosité qui est représentée en fonction de la radiance peut
se réduire (voir [SP94]) à l’équation suivante :
B(x) = E(x) + ρd H(x)
où :
– E(x) : la propre émission de l’élément en tant que source lumineuse ;
(2.3)
36
– ρd : paramètre de la capacité de ré-émission d’un élément ;
– H(x) : densité du flux incident, représentant l’énergie reçue de l’environnement ;
Le terme H(x) de l’équation (2.3) est un terme difficile à calculer ; il est représenté en
fonction de la radiance incidente Li par l’intégral hémisphérique :
Z
H(x) =
Li (x, θ, φ) cos θdω
(2.4)
Ω
Dans un milieu non participatif où la lumière se propage en ligne droite, en supposant
les objets opaques l’équation (2.4) peut s’écrire comme :
Z
0
cos θ cos θ
V (x, y)dy
(2.5)
B(x) = Be (x) + ρd
B(y)
πr2
y∈S
où :
– Be (x) : la propre émission de l’élément x en tant que source lumineuse ;
– ρd : paramètre de la capacité de ré-émission d’un élément ;
– r : distance entre les éléments kx − yk ;
– cos θ : traduit l’importance de l’incidence dans le modèle d’éclairement diffus ;
0
– cosr2θ : traduit l’influence de y sur x ;
– V (x, y) : une fonction binaire (équation (2.6)) représentant la visibilité entre les
deux points x et y.
La Figure 2.8 montre un exemple du calcul de la radiosité au point x depuis y qui dépend
0
de la distance entre les deux point x et y, et des deux angles θ et θ

1 si y est visible depuis x
V (x, y) =
(2.6)
 0 sinon
2.4.2
Discrétisation de l’équation de radiosité
Le calcul de la radiosité est basé sur la discrétisation de la scène, c’est-à-dire sur un
maillage des surfaces en patchs. Cela permet alors la discrétisation de l’équation (2.5)
qui fait apparaître une notion nouvelle, le facteur de forme (voir Section 2.4.2.4).
2.4.2.1
Radiosité et patchs
La subdivision des surfaces en patchs, demande certaines estimations pour le calcul
de radiosité. La radiosité est considérée uniforme pour un patch donné. Le paramètre de
la capacité de ré-émission d’un élément (ρd ), est encore considéré comme constant sur
un patch.
37
Fig. 2.8 – La radiosité au point x depuis y dépend de la distance entre x et y et de leurs
orientations respectives
2.4.2.2
Equation discrétisée
L’équation (2.5) de radiosité une fois discrétisée est écrite ([SP94]) :
X
Bi = Bei + ρi
Bj Fij
(2.7)
j
avec :
1
Fij =
Ai
Z
x∈Pi
Z
y∈Pj
0
cos θ cos θ
V (x, y)dydx
πr2
(2.8)
Le terme Fij de l’équation (2.8) est le facteur de forme. Pi et Pj représente les patchs
i et j. Ai et Aj sont les surfaces des deux patchs Pi et Pj . Les autres termes de l’équation
(2.7) et (2.8) ont la même signification que dans l’équation (2.5).
L’équation (2.7) peut être écrite sous forme matricielle (2.9) formant un système
linéaire à résoudre :

 
 
 

B1
Be1
ρ1 F11 ρ1 F12 . . . ρ1 F1n
B1

 
 
 

 B   B   ρF
  B 
ρ
F
.
.
.
ρ
F
2
e2
2
21
2
22
2
2n
2

 
 
 

(2.9)
 . = . + .
· . 
..
..
.
 ..   ..   ..



.
.
.

 
 
 

Bn
Ben
ρn Fn1 ρn Fn2 . . . ρn Fnn
Bn
L’équation (2.9) peut à son tour s’écrire sous la forme :

1 − ρ1 F11

 −ρ F
2 21


..

.

−ρn Fn1
38
...
−ρ1 F1n
 
B1
Be1

1 − ρ2 F22 . . .
..
.
−ρ2 F2n
..
.
 
 
 
·
 
 
 
  B
  e2
= .
  ..
 
Bn
Ben






−ρ1 F12
−ρn Fn2
. . . 1 − ρn Fnn
B2
..
.


(2.10)
Dans le système d’équations (2.10), les coefficients de réflexion (ρ1 ...ρn ) sont des
termes dépendant des matériaux et donc ils sont connus. Les termes Be1 ...Ben représente
la propre émittance des points comme source de lumière, et ils sont connus aussi. Les
deux inconnus sont les facteurs de forme et les radiosités Be1 ...Ben . Résoudre ce système
d’équations, revient alors à calculer la matrice de facteurs de forme. Une fois la matrice
de facteurs de forme calculée le seul inconnu est alors les radiosités. Les deux calculs de
la matrice de facteurs de forme et les radiosités sont expliqués respectivement dans les
Sections 2.4.2.4 et 2.4.3.
2.4.2.3
Étapes de résolution
Dans le système d’équations (2.10), seule la radiosité initiale (énergie émise localement) et les coefficients de réflexion sont connus. Les valeurs à calculer sont donc
les facteurs de forme et les radiosités. Trois étapes sont nécessaires afin de résoudre le
système d’équations :
– Calculer les facteurs de forme (Section 2.4.2.4) ;
– Résolution du système d’équations (Section 2.4.3) ;
– Visualisation de la scène : l’étape final de la radiosité est la visualisation des résultats. La radiosité obtenue est une valeur au centre des facettes ; pour obtenir des
variations continues de couleurs et de luminosité, il est important d’obtenir une
valeur de radiosité aux sommets des facettes (moyennes des valeurs de radiosité
des facettes de la valeur des facettes adjacentes) et d’effectuer une double interpolation de la couleur en fonction de la valeur de radiosité en chaque sommet des
facettes. Cette étape est similaire à l’interpolation utilisée par Gouraud [Gou71].
2.4.2.4
Facteur de Forme : définition et calcul
Le facteur de forme est un nombre associé à une paire d’éléments et reflète leur
dépendance mutuelle. Le facteur de forme Fij de l’équation (2.8) est la proportion de
l’énergie totale émise par le patch Pi et reçue par le patch Pj . Le facteur de forme est
une quantité géométrique et sa valeur dépend de la forme et de la position des surfaces
dans la scène. Plusieurs méthodes ont été proposées pour le calcul de facteurs de forme.
Parmi les méthodes de bases citons les méthodes projectives (équivalent de Nusselt),
l’hémi-cube et échantillonnage par lignes locales et globales :
39
– Méthodes projectives : les méthodes projectives sont basées sur l’équivalent de
Nusselt [Nus28]. Le facteur de forme d’un point x à un patch P est interprété
comme la projection de l’angle solide sous tendu par le patch P :
Z
1
cos θdw
Fx,P =
π ΩP
Fx,P représente la fraction de la surface unitaire dans le plan résultant de la projection de la surface du patch P sur le plan tangent à la surface au point x (Figure 2.9).
cos θ indique la projection de la surface sur le plan. ΩP est l’hémisphère unitaire
centrée au point x représentant l’ensemble de directions permettant à x de voir P .
Le facteur π est une normalisation ;
– L’hémi-cube : la deuxième méthode permettant le calcul de facteurs de forme est
l’hémi-cube. Il est basé sur Nusselt et suppose que l’hémisphère est discrétisée. Il a
été proposé par Cohen en 1985 [CG85], qui approxime l’hémisphère par cinq plans
de projection formant un demi-cube. Les faces de l’hémi-cube sont discrétisées en
proxels (cellules carrées). La projection d’un élément sur l’hémi-cube est représentée par l’ensemble des cellules qui intersectent cette projection (Figure 2.10). Le
facteur de forme d’un élément est alors approximé par la somme des facteurs de
formes de chaque cellule concernée.
Pour une cellule de coordonné (x, y, z), d’aire ∆S, le delta facteur de forme ∆F
est calculé suivant les équations ci-dessous :
pour la face supérieure ;
– ∆F = π(1+x12 +y2 )2 ∆S
– ∆F = π(y2 +zz 2 +1)2 ∆S
pour les faces latérales.
– Échantillonnage par lignes locales et globales : l’échantillonnage par lignes locales
pour le calcul de facteurs de forme permet d’évaluer les facteurs de forme de tous
les couples (Pi , Pj ), pour un i et un j donnés en échantillonnant des rayons partant
du patch Pi , déterminant pour chacun le premier patch Pj rencontré, et mettant
à jour le facteur de forme Fij associé. Dans l’échantillonnage par lignes globales,
les rayons peuvent également être lancés sans avoir pour origine un élément en
particulier. Ces rayons peuvent, selon leur orientation, traverser les surfaces et
une estimation des facteurs de forme peut être alors calculée. Une étude de tels
échantillonnages de trouve dans [Sbe93].
2.4.3
Résolution de l’équation de radiosité
L’équation de radiosité sous forme intégrale, l’équation (2.5) ainsi que l’équation discrétisée de radiosité équation (2.7) ne permettent pas le calcul de la radiosité. Il est
important alors de trouver des méthodes permettant la résolution du système d’équations. Concernant la résolution de l’équation sous forme intégrale, la littérature du calcul
numérique [RP98, Gas66, Kre89] propose plusieurs méthodes adaptées à ce genre de calcul. Ces méthodes peuvent être divisées en deux classes : la méthode de quadrature et
les méthodes de projection. Les méthodes de quadrature sont des approximations de la
Fig. 2.9 – Nusselt : illustration géométrique du facteur de forme
40
Fig. 2.10 – Hémi-cube : calcul du facteur
de forme
valeur numérique d’une intégrale. En général, ils remplacent le calcul de l’intégrale par
une somme pondérée prise en un certain nombre de points du domaine d’intégration.
Pour les méthodes de projection citons la méthode de Galerkin et la méthode de collocation. La méthode de Galerkin pour la résolution de la radiosité fournit une solution
approximative de radiosité avec une erreur résidue qui est orthogonal à l’ensemble de
solutions et donc à la solution en elle même [HW91b, Zat93, Fle84, SP94]. La méthode
de collocation est une alternative de la méthode de Galerkin, elle exige que le résidu soit
nul pour tous les points nodaux. Cette méthode est moins complexe que la méthode de
Galerkin mais elle extrait moins d’information que celle de Galerkin [SP94]. Des études
de la méthode de collocation dans le cas de l’équation de la radiosité ont été menées
dans [ACS00, Han02, Han03].
2.4.3.1
Méthodes Itératives de résolution
Concernant l’équation discrétisée de radiosité, les méthodes itératives sont généralement utilisées pour la résolution de ce genre d’équations. Ces méthodes sont les
plus utilisées dans la plupart des algorithmes de radiosité. Soit (Bi )i∈[1...n] le vecteur de
radiosité de chacun des patchs qu’on cherche à déterminer, et soit (Mi,j )i,j , la matrice
de facteur de forme (contenant ρi ), l’équation (2.10) peut s’écrire alors sous la forme
(I − M )B = Be qui est de la forme Ax = b.
En supposant que la matrice de facteurs de forme est calculée utilisant les méthodes
de calcul de facteur de forme (Section 2.4.2.4), la solution de radiosité est alors calculée
utilisant les méthodes itératives consistant à résoudre le système Ax = b. Le but de ces
méthodes de résolution itérative est de minimiser la différence entre la solution exacte
et la solution courante en minimisant le résidu. Si le résidu vaut zéro, cela indique qu’on
est arrivé à la solution désirée et qu’on a une bonne convergence. Parmi les méthodes
itératives il y a la relaxation de Jacobi, la relaxation de Gauss-Seidel et la relaxation de
Southwell.
41
– La relaxation de Jacobi :
Cette méthode garde deux copies de toutes les variable xi c’est à dire elle garde
une ancienne valeur et une nouvelle valeur. Elle est illustrée par la suite suivante :
bi −
(k+1)
xi
=
N
X
(k)
Aij xj
j6=i
Aii
k est l’étape k de l’algorithme et x(0) est initialisée à une valeur quelconque, par
exemple Be .
– La relaxation de Gauss-Seidel :
Elle est simple et efficace. Elle repose sur la relaxation de Jacobi et elle est représentée par l’équation suivante :
bi −
(k+1)
xi
=
X
Aij xk+1
j
−
0≤j<i
N
X
Aij xkj
i<j≤N
Aii
x(0) est initialisée à une valeur quelconque, par exemple Be . Cette relaxation a
une meilleur convergence que la relaxation de Jacobi quand la matrice A a une
diagonale strictement dominante. Elle permet aussi de gagner en mémoire vue
qu’un seul vecteur de stockage est utilisé.
– La relaxation de Southwell :
Cette méthode est différente de la méthode de Jacobi et de Gauss-Seidel. Dans
la relaxation de Jacobi et de Gauss-Seidel, la mise à jour de l’élément i se fait
en propageant l’énergie de tous les élément vers l’élément i. Cela est décrit par
le principe du “gathering” revenant à rassembler la lumière provenant de tous les
éléments sur le patch courant. La relaxation de southwell utilise une procédure de
“shooting”, où la mise à jour se fait en regardant l’énergie émanante de l’élément i
(Section 2.4.4.1).
2.4.4
Algorithmes avancés de radiosité
La méthode de radiosité nécessite le calcul de la matrice complète de facteurs de forme
(équation (2.9)), ce qui est coûteux à la fois en temps de calcul et en mémoire (stockage
de la matrice de facteur de forme). Une solution imaginable pourrait être la réduction du
nombre de patchs de la scène, or cela influence sur la précision de la méthode. Dans cette
section, différentes méthodes qui ont réduit la complexité soit en temps ou en mémoire
de la radiosité et qui ont simplifié la procédure de transfert d’énergie sont expliquées.
2.4.4.1
42
Radiosité progressive
La résolution de l’équation (2.9) de radiosité nécessite le calcul de la matrice des
facteurs de forme avant qu’une méthode itérative (Gauss-Seidel) soit appliquée. Une reformulation de la solution peut être effectuée en utilisant Southwell-Relaxation au lieu
de Gauss-Seidel. Southwell-Relaxation mène à un algorithme progressif de radiosité. Les
deux algorithmes Gauss-Seidel et Southwell-Relaxation fonctionnent de manière réversible. Comme il a été noté dans la Section 2.4.3.1, la méthode de Gauss-Seidel calcule la
radiosité Bi du patch i en se basant sur la radiosité de tous les autres patchs. Cela est
décrit par le principe du “gathering” ou “rassemblement” qui revient à rassembler toute
la lumière provenant de tous les autres patchs sur le patch courant (Figure 2.11). En
contraste, la méthode de Southwell utilise une procédure de “shooting” ou “tirage”, qui
envoie l’énergie du patch courant à tous les autres (Figure 2.12).
Le principe de la radiosité progressive est le suivant : chaque patch maintient une
radiosité courante Bi et une radiosité non envoyé ∆Bi représentant la radiosité résiduelle.
Le fonctionnement de l’algorithme est alors comme suit : le patch ayant le plus grand
∆Bi est choisi comme émetteur ; il lance sa radiosité aux autres patchs. La radiosité non
envoyé ∆Bi des autres patchs est mise à jour et ∆Bi du patch courant passe à zéro après
envoi. Cette technique progressive offre plusieurs avantages qui se résument comme suit :
– Le calcul de la radiosité se fait au fur et à mesure ; A chaque étape, le patch le plus
clair, ayant le plus grand ∆Bi est choisi comme émetteur. A chaque itération, la
radiosité du patch est mise à jour rapprochant ainsi le résultat du résultat souhaité.
Au niveau d’affichage, l’image est sombre au début, elle devient plus claire à chaque
étape grâce à la propagation de l’énergie.
Le rapprochement au résultat désiré à chaque itération permet l’affichage de la
solution à chaque étape avant d’obtenir une convergence vers la bonne solution.
– Minimisation de la mémoire : il n’y a plus besoin de calcul de la matrice complète
de facteurs de forme. À chaque étape une colonne de la matrice est utilisée. Dans
certains cas, où une source est choisie comme émetteur un certains nombres de fois,
il y a besoin d’un re-calcul d’une colonne. Malgré ce calcul qui peut se répéter,
il ne faut pas oublier que la mémoire est réduite car une partie de la matrice est
utilisée. De plus certains facteurs de forme ne sont pas calculés du tout ; il s’agit
des patchs qui ne sont jamais choisis comme émetteur.
Malgré les avantages offerts par la méthode de radiosité progressive, un effet non
désiré de cette approche au niveau d’affichage se pose parfois. Les endroits de la scène
qui ne sont pas directement visible à partir des sources lumineuses, dépendent des phénomènes de réflexions pour recevoir de la lumière ce qui fait qu’ils sont très sombres
dans les premières étapes de l’algorithme. Une solution pour ces cas à été proposée par
Cohen et ses collègues [CCWG88] qui proposent de rajouter un facteur ambiant pour
remédier à ce genre de problème.
Fig. 2.11 – Rassemblement des rayons
provenant de plusieurs patchs vers le
patch i
2.4.4.2
43
Fig. 2.12 – Envoie de l’énergie du Patch
i vers les autres patchs
Substructuring et subdivision adaptative
Il a été remarqué que la précision désirée diffère entre les deux moments de la réception et de l’émission ; une grande précision est demandée au moment de la réception
quant à l’émission, moins de précision est nécessaire. Ces différentes précisions peuvent
être accomplies en mémorisant avec chaque patch une certaine subdivision. Quand le
patch est émetteur, une résolution fine n’est pas nécessaire alors une résolution moyenne
est suffisante, alors qu’en mode réception, la plus fine résolution est choisie. Le seul inconvénient de cette subdivision en patch est qu’elle doit être effectuée à l’avance. Il est
possible d’effectuer une subdivision adaptative du maillage qui sera calculée au fur et à
mesure quand les informations de radiosité sont disponibles. Cela revient à générer des
éléments dans les zones où une remarquable variation de radiosité est repérée. Il est alors
possible de mettre un certains seuils et de regarder le gradient ; une subdivision est effectuée quand le gradient dépasse le seuil. Un quadtree peut être utilisé pour représenter
la subdivision de la surface. Dans un quadtree (Figure 2.13), en regardant la variation
de radiosité, un élément est subdivisé ou non ; chaque noeud représente un patch d’une
surface et pointe vers quatre fils correspondant à la subdivision du patch.
2.4.4.3
Radiosité hiérarchique
La radiosité hiérarchique est la combinaison de substructuring et subdivision adaptative. Cet algorithme est considéré comme le plus important des algorithmes de radiosité
[HSA91, HS92]. La scène n’est pas divisée en avance en maillages ; la subdivision est
créée pendant la procédure du calcul de radiosité. Le but de la subdivision est d’établir
un certains liens entre deux paires de polygones pour le transfert d’énergie. Une fois les
liens établis, la solution itérative de radiosité est calculée. Elle consiste à rassembler la
radiosité parmi les liens et la propager.
44
Fig. 2.13 – Le quadtree utilisé pour la subdivision des éléments
La complexité de la méthode hiérarchique est de O(k 2 + n), k étant le nombre de polygones et n le nombre de patchs. La complexité est dépendante du nombre de polygones,
ce qui fait que la complexité est quadratique par rapport au nombre de polygones.
2.4.4.4
Radiosité hiérarchique et clustering
Le clustering consiste à regrouper des objets pour ainsi estimer l’énergie entre les
groupes d’objets. Le clustering peut être utilisé avec les algorithmes de radiosité progressive. Kok [Kok93] a proposé une méthode de groupement des petits patchs pour la
méthode de radiosité progressive. Dans cette méthode un groupe envoie et reçoit l’énergie
de l’environnement.
Le clustering est surtout utilisé avec l’algorithme de radiosité hiérarchique [SAG94,
SNSS97, GH96, HDSD99]. L’algorithme hiérarchique de la radiosité a une complexité
de O(k 2 + n) ; si k est beaucoup plus grand que n, l’algorithme devient très lent. Une
solution consiste à utiliser le principe du clustering et à étendre alors l’algorithme pour
qu’il fasse des échanges entre des objets ou groupes d’objets diminuant ainsi le nombre
de liens. Or les algorithmes du clustering avec la radiosité hiérarchique sont coûteux
en terme de calcul de la visibilité. Des efforts ont été faits pour réduire le calcul de
la visibilité ; certains sont basés sur une pré-traitement dépendant de la géométrie de
l’environnement [CT97, HW91a, TH93] et proposent donc une estimation précise de la
visibilité entre un groupe d’objets. Une estimation moins précise de la visibilité une
mais très rapide est présentée dans [MBSB03]. Leblanc et co. [LP00] construisent une
hiérarchie appelée “Face clustering”, qui produit des groupes de triangles adjacents ayant
45
des vecteurs normaux similaires.
Notons que le principe du clustering est très utile quand les objets sont séparés
(Figure 2.14) et ayant un petit effet sur la précision de la solution finale de radiosité ;
dans ce cas il est possible de diminuer le nombre de liens. Pour les objets proches
(Figure 2.15), il n’est plus possible de diminuer le nombre de liens ; les liens doivent être
accomplis entre des polygones simples pour obtenir plus de précision.
Le clustering utilisé avec la radiosité hiérarchique a diminué la complexité de celle-ci
de O(n2 + k) à O(k + n) selon l’algorithme.
Fig. 2.14 – Clustering : Pour des objets éloignés une seul lien est suffisant
Fig. 2.15 – Clustering : Pour des objets proche plusieurs liens sont nécessaire pour plus
de précision
2.4.5
Radiosité utilisant l’approche Monte Carlo
Le modèle d’illumination peut être traité comme une procédure stochastique de simulation au lieu d’un modèle déterministe. C’est là que se situe l’idée fondamentale des
méthodes de Monte Carlo, qui formulent une solution à un problème comme un paramètre de variables aléatoires. L’approche de Monte Carlo peut être utilisée pour résoudre
l’équation de radiosité au lieu des méthodes déterministes. La méthode de radiosité progressive peut être vue comme une stratégie d’énergie émanante (shooting-energy). Les
sources et les surfaces émettent l’énergie vers d’autres surfaces. Cette énergie émise est
46
interprétée d’une manière déterministe ; les particules sont émises des sources dans différentes directions, quand ils rencontrent les objets, ils subissent des réflexions et des
réfractions ou perd de l’énergie. Ce modèle est implémenté par une approche Monte
Carlo.
L’utilisation de Monte Carlo offre des avantages et des inconvénients. La solution
est correcte donnant une bonne illustration des inter-réflexions dans l’environnement ce
qui est un avantage ; aussi il n’y a pas besoin de stocker les facteurs de formes ce qui
minimise la mémoire. L’inconvénient de la méthode de Monte Carlo est que dans le cas
d’une discrétisation fine, des artéfacts sont remarqués exigeant une augmentation du
nombre de rayons.
La technique de Monte Carlo est utilisée dans la méthode de radiosité pour le calcul
des facteurs de formes ainsi que pour la résolution de l’équation de radiosité.
Les facteurs de formes sont simulés en faisant une répartition des droites en respectant
une distribution du cosinus. Deux manières pour cette répartition sont possibles ; une
génération locale ou globale des droites. Une génération locale peut être faite en utilisant
une technique proposée par Tobler et ses collègues [TNSP98], basée sur la méthode de
Nusselts qui génère la distribution du cosinus. Cette technique consiste à choisir un point
x ayant une distribution uniforme de la surface d’un patch p, prendre un point aléatoire
y d’une sphère unitaire tangente au patch p au point x ; la droite générée suit alors la
direction xy (Figure 2.16). La génération globale est différente de la génération locale,
elle ne fait pas une répartition à partir d’un patch précis mais elle peut traverser la scène
toute entière. Plusieurs techniques ont été utilisées pour générer les droites globales citons
parmi ces technique “Bundles of Lines” qui est un groupe parallèle de droites obtenu en
définissant une certaines distances entre les droites représentant la résolution. Ces droites
sont construites à partir du plan tangent à une sphère (Figure 2.17).
Les droites générées d’une manière globale ou locale peuvent être utilisées pour le
calcul des facteurs de formes entre les patchs, évitant le stockage de la matrice de facteurs
de forme.
La résolution de l’équation de radiosité en utilisant la technique de Monte Carlo est
effectuée en étendant l’équation de radiosité en une série de Neumann. Notons finalement
que la méthode de Monte Carlo a été utilisée par plusieurs chercheurs pour le calcul de
l’illumination globale et de la radiosité montrant des résultats encourageant [Neu95,
SPNP96, CMS98, Bes01, FP93].
2.4.6
Autres algorithmes de radiosité
Les algorithmes avancés de la radiosité ont réduit la complexité du calcul. Ces méthodes sont les plus répandues dans le cadre du calcul de la radiosité. Il y a toujours
d’autres approches adaptées pour le calcul de la radiosité. Il y a par exemple les méthodes de radiosité à base d’ondelettes [PB94, GSCH93, CAH00, HCA00]. Aussi les
méthodes de radiosité utilisant un modèle géométrique comme la méthode étudiée dans
Fig. 2.16 – Génération locale de droites
47
Fig. 2.17 – Génération globale de
droites utilisant une génération parallèle (Bundle of lines)
[AMP00a, AMP00b], qui propose l’utilisation d’un atlas “disk-like patches”, constitué de
patchs qui recouvrent une surface et qui peuvent se chevaucher.
2.5
État de l’art : parallélisation des méthodes de radiosité
La plupart des méthodes de radiosité sont coûteuses en temps de calcul et en mémoire. Cela a poussé les chercheurs à avoir recours au parallélisme afin de minimiser
ces deux facteurs permettant ainsi de traiter de grandes scènes qui n’entrent pas en
mémoire en un temps de calcul minimisé. Les différentes caractérisations des méthodes
de radiosité reposent sur la stratégie utilisée pour paralléliser l’algorithme ainsi que l’architecture de la machine (multi-ordinateurs, multiprocesseurs, etc ...) et son système de
mémoire (partagée ou distribuée). La stratégie de parallélisme diffère selon l’algorithme
de radiosité ; l’algorithme est la manière de calculer la matrice de radiosité et de facteur
de forme. Comme il a été noté en Section 2.4.4 plusieurs simplification sont effectuées
pour la résolution de l’équation de radiosité. Par exemple la méthode progressive de
radiosité choisit le patch ayant la plus grande énergie comme émetteur, il émet l’énergie
à tous les autres ; la parallélisation de cet algorithme est alors différente de celui de la
radiosité hiérarchique et le clustering où une subdivision a lieu pour établir un lien pour
le transfert d’énergie.
Du point de vue système de mémoire, on peut distinguer deux systèmes : Le système
à mémoire partagée et le système à mémoire distribuée. Le système à mémoire distribuée peut être divisé en deux systèmes à son tour ; les grappes de stations de travail et
le système distribué à mémoire partagée. Les grappes de stations de travail sont composées de plusieurs machines où le transfert entre les machines est effectué en utilisant
une stratégie de transfert de messages. Le système distribué à mémoire partagée utilise
48
des variables partagées pour la communication (plus de détails sur le système mémoire
se trouvent dans le chapitre 1). Dans les sections qui viennent, une présentation des
différentes stratégies est présentée.
2.5.1
Parallélisation de la radiosité progressive
L’algorithme de radiosité progressive est un algorithme interactif permettant de visualiser des images intermédiaires. La procédure consistant à choisir le patch ayant la
plus grande énergie comme émetteur fait augmenter la rapidité de convergence de l’algorithme. Malgré cela le temps de calcul de radiosité demeure important nécessitant
ainsi du calcul parallèle pour améliorer l’interactivité en réduisant le temps de calcul
autant que possible. Plusieurs travaux de parallélisme ont été effectués pour paralléliser
la méthode de radiosité progressive.
Dans [BW90] la méthode de radiosité progressive est parallélisée sur de multiprocesseurs graphique de machine à mémoire partagée. La génération des facteurs de forme,
la distribution de la lumière et le choix du patch émetteur est effectuée en parallèle sur
les processeurs.
Recker et co. [RGG90] proposent deux méthodes pour accélérer la méthode de radiosité progressive. L’algorithme de l’hémi-cube est modifié pour accélérer le calcul du
facteur de forme. La méthode de radiosité est parallélisée sur des grappes de stations
de travail ayant un parallélisme grossier (coarse grained network cluster of Hewlett Packard workstations). Cette parallélisation est système client serveur. le serveur maintient
la liste des patchs et la radiosité des éléments. Un processeur est utilisé pour l’affichage.
Les autres n − 2 processeurs sont les clients. Les clients ont une copie dupliquée de la
géométrie de l’environnement. La communication entre le serveur et les clients se déroule
de la manière suivante : le serveur détermine les n − 2 patchs ayant la plus grande radiosité, et fait un envoi du type broadcast donnant un patch à chaque client. Les clients
calculent le vecteur de facteur de forme du patch à tous les éléments et le renvoient au
serveur. Le serveur renvoit alors à chacun des clients un nouveau patch et la procédure
se poursuit.
Une parallélisation applicable pour des machines SIMD et MIMD et basée sur une
projection de l’environnement est présentée dans [VP92]. Dans cette approche une surface de projection similaire a celle proposée dans [RR97] ; cette surface de projection
est décrite comme étant un plan capable de capter 90 pourcent de la lumière venant du
patch émetteur.
Bouatouch et co. [BMP] ont présenté une approche qui consiste à paralléliser la méthode de radiosité en utilisant une mémoire virtuelle partagée. Dans cette parallélisation,
les émissions sont effectuées en parallèle. Chaque processeur choisit un patch émetteur,
trouve le facteur de forme entre ce patch et les autres patchs de la scène et distribue
l’énergie de ce patch émetteur aux autres patchs de la scène. Le travail de chaque processeur est indépendant des autres processeurs, ce qui ne nécessite pas une synchronisation
entre les processeurs. La mise à jour des valeurs de radiosité est effectuée en parallèle.
49
Pour accélérer les émissions, le patch choisi doit avoir une énergie maximale, ce choix
est simple dans un algorithme séquentiel mais il est dur en parallèle car un processeur
ne doit pas choisir un patch déjà choisi par un autre processeur. Une solution consiste
à mettre à zéro l’énergie du patch émetteur quand il est choisi par un processeur ; cela
oblige à faire une section critique (voir [BMP]). Or la section critique crée des attentes
importantes. Ces attentes peuvent être diminuées en traitant la mise à jour de la radiosité ainsi que la sélection du patch émetteur en parallèle. Cet algorithme parallèle a été
testé sur un nombre de processeurs allant de 1 à 32 avec des scènes allant de 2000 à
50000 patchs ; une accélération presque égale au nombre de processeurs et une efficacité
de 82 pourcent est remarquée.
Une méthode basée sur la circulation des données des patchs a été proposée dans
[Aaz96]. La parallélisation est effectuée sur des multi-ordinateurs (coarse grained) en tenant compte de certaines topologies particulières entres les machines. Dans l’algorithme
parallèle, P émissions concurrents de radiosité sont effectuées en même temps sur les
multi-ordinateurs. Aykanat et ses collèges ont montré que pour leur algorithme l’utilisation d’une topologie simple (ring) à la place des topologies riches comme l’hypercube,
ne dégrade pas l’efficacité de l’algorithme. La parallélisation est établie de manière synchrone permettant l’obtention de plus de cohérence en même temps une convergence
plus rapide.
Renaud et Rousselle [RR97] utilisent des machines SIMD caractérisées par un grand
nombre de simples processeurs dont la puissance est donnée par le nombre de processeurs
plutôt que par la capacité du calcul. Le calcul de facteur de forme et de l’émission (patch
ayant l’énergie la plus grande) est parallélisé permettant un calcul rapide du système
d’équations de radiosité. Une estimation de facteur de forme est obtenue en utilisant une
surface circulaire (disk projection area) de projection basée sur la méthode de Nusselt
[Nus28] diminuant largement le temps de calcul.
Guittton et co. [GRS95] parallélisent une méthode stochastique de calcul de radiosité
réalisée sur des machines à mémoire distribuées, un cluster utilisant le transfert de messages comme moyen de communication entre les noeuds. La méthode divise la scène en
plusieurs parties et donne à chaque processeur une de ces parties ; cela évite la limitation
à des scènes qui sont plus petites que la mémoire du processeur et permet donc de traiter
des grandes scènes. La division de la scène est régulière, elle peut être en grille, tranche
ou pyramide, le nombre de divisions est calculé de manière à respecter l’équilibrage de
charge entre les processeurs. Chaque processeur traite ses propres rayons, s’il n’y a pas
intersection des rayons avec les patchs, le calcul est transféré à l’espace voisin à l’aide du
transfert des messages. Cette parallélisation utilise des threads pour repartir les tâches
et augmenter ainsi le degré du parallélisme.
Dans [YIY97] Yu et co. font intégrer une subdivision des surfaces en maillage. Une
première division en maillage triangulaire est effectuée, pour chacun des patchs de ce
maillage, une subdivision peut se faire s’il y a encore besoin. Une distribution statique
est effectuée afin de distribuer les patchs entre les processeurs.
2.5.2
50
Parallélisation de la radiosité hiérarchique
Malgré la complexité minimisée offerte par la radiosité hiérarchique par rapport à
l’algorithme classique de radiosité. Cette méthode demeure complexe pour des grandes
scènes nécessitant ainsi un calcul en parallèle. Plusieurs approches ont été utilisées pour
paralléliser l’algorithme de la radiosité hiérarchique.
[SGL94] présente un algorithme parallèle de calcul de la radiosité hiérarchique. Ils
ont utilisés des arbres binaires au lieu des quadtree pour faciliter le calcul de visibilité
dans leur algorithme séquentiel. Ils ont remarqué qu’une distribution statique engendre
des déséquilibres de charges importantes, car la distribution des charges pour les paires
de polygones n’est pas uniforme. Une distribution dynamique est alors effectuée pour
obtenir un équilibrage de charge. L’implémentation parallèle de l’algorithme attribue
à chaque processeur sa propre queue de travail. A chaque subdivision des patchs, de
nouveaux travaux sont rajoutés à la queue du processeur impliqué. Si un processeur
finit ses travaux, il peut aider les autres processeurs à finir leur queue de travail. L’accès
d’un processeur aux données d’un autre est direct à cause de l’utilisation de machine
distribuée à mémoire partagée. Dans l’algorithme il y a aussi utilisation du ray-casting,
du shear warp volume rendering et ray tracing qui sont aussi parallélisés afin de minimiser
le temps de calcul le plus possible. Les résultats obtenus sont encourageants.
T.A. Finkhouser décrit dans son papier [Fun96] l’implémentation d’une méthode de
radiosité basée sur une technique de groupement itératif utilisant une solution hiérarchique concurrente de radiosité. Le système est un système maître esclaves utilisant les
messages TCP comme moyen de communication. La parallélisation consiste à répartir
les patchs de la scène en groupes, les processeurs traitent différents groupes en parallèle
et calcule la radiosité. Les esclaves représentent les différents processeurs et calculent
la radiosité de leur groupe des patchs. Le maître effectue l’équilibrage de charges et la
distribution des données. Il sélectionne le groupe à traiter par les processeurs, un groupe
particulier pour être traité par un processeur donné. La construction des groupes effectuée par le maître est très délicate et doit prendre en considération les tailles du groupe.
Une fois les groupes construits, le maître envoie un groupe parmi les groupes présents à
un processeur donné et il lui envoie aussi tous les patchs qui sont visibles à travers les
patchs du groupe choisi. Une fois les données envoyées, le maître annonce au processeur
qu’il peut commencer son traitement de radiosité. Les esclaves à la fin de leur exécution
du calcul de radiosité, envoient au maître les nouvelles valeurs, le maître les met à jour
pour qu’ils soient prêt à être traitées par les esclaves pour plus tard. Cette parallélisation a montré une amélioration du temps de 65-75 pourcent pour de nombre d’esclaves
variant entre 1 et 8.
[FY97] propose un algorithme qui partitionne une scène complexe en petites sous
scènes ou cellules dépendantes de cohérence spatiale et visuelle. Chacune des sous scènes
peut être parallélisée individuellement. La parallélisation utilise l’idée maître esclaves
comme dans [Fun96], or elle est plus fine que celle-ci, car elle distribue les patchs entre
les esclaves, ce qui permet de se contenter des esclaves avec des mémoires plus petites et
51
ayant moins de capacité de calcul. Fang et Yang ont remarqué que la méthode d’émission
est meilleur que celle du rassemblement pour leur algorithme, contrairement à ce qui a été
noté dans [SGL94] où le rassemblement est meilleur que le shooting sur des architectures
à mémoire partagée pour des simples scènes. Cela est dû au fait que la méthode du
rassemblement demande plus d’itérations que l’émission, aussi avec l’émission (shooting)
il y a une convergence qui est plus rapide car les patchs ayant la plus grande énergie
sont choisi comme émetteur. L’algorithme est désigné pour des machines parallèles à
mémoires distribuées utilisant le transfert de message.
Dans [RS97] Richard et co. proposent un algorithme parallèle pour le calcul de la
radiosité diffus et spéculaire. La parallélisation est effectuée sur des machines distribuées
à mémoire partagée. Comme [SGL94], le parallélisme est généré d’une manière dynamique utilisant des queues de travaux. Quand le processeur finit le traitement de ses
queues il peut aider les autres à finir leurs queues pour garantir ainsi l’équilibrage de
charge. Le traitement diffus et spéculaire ensemble consomme plus de mémoire que le
modèle diffus seul ; le programme spéculaire doit traiter plusieurs sources (patchs) pour
chaque destination. Des efforts supplémentaires pour diminuer la mémoire utilisé par le
programme doivent être réalisés permettant ainsi le traitement de plus grandes scènes.
Meneveaux et co [MB98] et [MB99] proposent un algorithme hiérarchique parallèle
de type (SPMD) pouvant être appliqué à tout type d’environnement architectural complexe. Cet algorithme utilise l’environnement de programmation parallèle MPI et peut
être exécuté sur un réseau hétérogène de machines, une machine parallèle ou les deux ensembles. L’environnement est découpé en plusieurs régions appelées cellules. Pour chaque
cellule, des groupes de surfaces (ou clusters) sont déterminés et un graphe représentant
la visibilité entre ces clusters est construit. Ce graphe est divisé en sous graphes et
chaque sous graphes est attribué à un processeur qui est chargé à calculer l’éclairement
des clusters qui lui ont été attribué. Dans cet algorithme, chaque processeur effectue le
calcul de radiosité des ses propres groupes en utilisant une approche de rassemblement
(gathering) ; le rassemblement sur un processeur donné peut demander des informations
d’autres processeurs nécessitant ainsi de transfert des données entre les processeurs. Un
ordonnancement efficace du calcul est alors nécessaire pour réduire les échanges d’informations entre le disque et la mémoire [Men98, MBM97]. Dans cet article, une méthode
dynamique d’équilibrage de charges est mise en oeuvre. Cette méthode est testée sur
différents ordinateurs à réseau Ethernet local et une remarquable accélération est notée.
Garmann [Gar99] présente une analyse expérimentale de la radiosité hiérarchique.
Des mesures concernant trois sujets importants sont étudiées : équilibrage de charge,
communication et congestion.
– Équilibrage : La méthode de radiosité hiérarchique est divisée en plusieurs tâches
et les dépendances entre les tâches sont décrites. Un partitionnement de l’algorithme en graphe est effectué et le degré de partitionnement est mis en oeuvre.
Le graphe a un faible partitionnement à cause de la grande quantité de communication causée par le calcul de visibilité. Un partitionnement spatial a montré des
résultats meilleurs que le Metis ;
52
– Communication : La quantité de tâches change d’une itération à une autre et alors
un équilibrage de charge est nécessaire et ne pourra pas être évité ;
– Congestion : L’apparition de la congestion est due au fait que le nombre de canaux
entre les paires de processeurs utilisé pour la radiosité hiérarchique est plus grand
que le nombre de canaux disponibles par les super-ordinateurs.
Dans [SH00] Sillion et Hasenfratz décrivent une extension de l’algorithme de radiosité
hiérarchique pour la simulation de l’illumination globale. Ils décrivent une méthode basée
sur un scheduler qui a permis une parallélisation simple avec un certains ordonnancement
des travaux. Ils ont montré qu’un groupement de travaux est suffisant pour éviter les
pertes de temps en synchronisation. Les tests sont effectués sur un système distribué
à mémoire partagée. Une accélération remarquable est obtenue en utilisant toute la
capacité des machines.
2.5.3
Autres méthodes
Plusieurs chercheurs ont essayé d’améliorer la méthode de radiosité en présentant
de nouvelles approches ou stratégie de parallélisme. Dans [RAPP97], Renambot et co.
présentent une nouvelle technique de calcul de la radiosité qui consiste à partager la
scène initiale en sous environnements et à calculer la radiosité de chacun de ces sous
environnements. Les échanges de radiosité entre les sous environnements sont effectués
en utilisant le concept d’interfaces virtuelle et de masque de visibilité. L’interface virtuelle
facilite le transfert d’énergie entre les sous environnements. Au début chacun des sous
environnements est traité ; une fois les environnements traités, le transfert d’énergie de
chaque environnement local à son voisin est effectué. Ce transfert d’un environnement à
son voisin a nécessité l’introduction d’un masque de visibilité qui détermine la visibilité
du patch par rapport à son environnement. Le masque de visibilité est une hémisphère
échantillonnée identique à celle utilisée généralement pour trouver le facteur de forme.
Le masque de visibilité est crée pour les sources existant dans l’environnement local et
sa valeur est mise à jours quand c’est nécessaire. La Figure 2.18 illustre l’idée du masque
de visibilité ; pour un rayon rencontrant un objet dans l’environnement local, le masque
de visibilité est mis à faux, sinon la visibilité est vraie. Notons que dans cette méthode il
faut faire attention au placement de l’interface virtuelle pour une meilleure performance ;
par exemple une interface collée à un mur peut arrêter la propagation de la lumière. La
parallélisation de la méthode consiste alors à distribuer les sous environnements entre
les processeurs et ensuite à renvoyer les masques de visibilité entre les processeurs pour
effectuer les échanges de radiosité. Chaque processeur doit donc avoir accès aux masques
de visibilité générés par les autres processeurs. Cette parallélisation a été testée sur des
machines distribuées à mémoire partagée SGI Origin 2000 et a diminué le temps de
calcul d’un facteur de 5.
Dans [DDP99] Durant et co. présentent une approche rapide qui a produit une solution précise d’illumination pour l’illumination directe (scène avec plusieurs sources de
53
Fig. 2.18 – Interface virtuelle [RAPP97]
lumière) et aussi pour l’illumination indirecte pour les scènes qui sont frappées par la
lumière indirecte. Durant et co ont étendu la notion du squelette de visibilité qui a été
présentée dans [DDP97]. Le squelette de visibilité est une structure de donnée qui code
toutes les relations de visibilité globale d’une scène en 3D. Cette notion a été étendue en
remplaçant la représentation de noeuds et arcs par une structure hiérarchique de liens
d’un polygone à un polygone (sommet à un polygone). Ces extensions ont permis le
calcul d’un facteur de forme point-polygone exact pour une paire de sommet-polygone
dans une scène.
Cavin présente dans [Cav00, CAP98] des techniques de partitionnement et d’ordonnancement pour la parallélisation d’un algorithme de radiosité hiérarchique à base
d’ondelettes sur des ordinateurs à mémoire distribuée virtuellement partagée ; cette parallélisation a permis une bonne répartition de la charge de travail entre les processeurs
tout en garantissant la localité des données en mémoire.
2.6
Illumination globale aujourd’hui
Le parallélisme utilisé pour paralléliser les méthodes de radiosité a réussi à diminuer
le temps de calcul et parfois la mémoire (mémoire distribuée) de celles-ci. Or le parallélisme n’est pas seulement appliqué sur les méthodes de radiosité, il s’applique aussi sur
les différents algorithmes de lancer de rayons comme le ray tracing [FSGS04, RAH07], le
photon mapping [GWS04] et d’autres. Récemment, les concepts des cartes graphiques ou
GPU (graphics hardware acceleration) sont suggérés pour améliorer le calcul de l’illumination globale. Les méthodes d’illumination globale sont utilisées pour générer des
images réelles et de nos jours, un des axes privilégiés de la recherche est d’arriver à
résoudre ces calculs d’illumination avec des solutions interactives utilisant la puissance
des cartes graphiques. Les cartes graphiques ont évolué et ont atteint une capacité de
54
traitement largement accélérée. Les cartes graphiques sont alors utilisées dans le ray
tracing [PBMH02], le photon mapping [Lar04]. Aussi ils sont utilisées pour le calcul de
la radiosité ; la résolution de la radiosité nécessite un certains nombre d’itérations, en
limitant ce nombre, il est possible d’effectuer le calcul de la radiosité sur carte graphique
[NPG03].
2.7
Conclusion
Dans ce chapitre, des notions de synthèse d’images, d’infographie et des modèles
d’illumination ont été introduites. Les algorithmes de lancer de rayons sont exposés. Ces
algorithmes sont utilisés pour le calcul d’illumination globale. La radiosité avec ses différentes équations ainsi que les méthodes de résolution du système d’équations sont présentées. Les méthodes avancées de radiosité sont expliquées. Parmi ces méthodes avancées,
La radiosité progressive n’a pas réduit la complexité mais a permis la visualisation d’un
résultat intermédiaire après un certains temps permettant ainsi une visualisation des
étapes de la simulation jusqu’à la convergence. La radiosité hiérarchique et son extension au clustering étant linéaire en temps de calcul a montré une bonne efficacité pour
le calcul de radiosité.
Malgré les améliorations offertes par les algorithmes avancés, le traitement de radiosité sur des grandes scènes demeure non raisonnable du point de vue temps de calcul
ainsi que consommation mémoire, menant au parallélisme qui est la solution idéale pour
ce genre de problèmes. Les différentes parallélisations des méthodes de radiosité ont
montré un calcul accéléré par rapport au calcul séquentiel et ont parfois réduit l’espace
mémoire demandé (cas où les données sont distribuées).
Une majeure partie du chapitre concerne les approches de radiosité ainsi que les
différentes parallélisations des méthodes de radiosité. Une concentration est faite sur la
radiosité car la méthode d’illumination globale par voxels qu’on cherche à paralléliser
au cours de ce travail présente des points communs avec la radiosité. Cette méthode
est différentes des méthodes avancées de radiosité présentées dans ce chapitre. Elle se
caractérise par le calcul de la visibilité avec une complexité optimale. Elle est basée sur
une discrétisation des surfaces en voxels et un partitionnement de l’espace en droites 3D
de voxels.
Chapitre 3
Méthode d’illumination globale par
voxels : Algorithme et étude de
convergence
Les algorithmes d’illumination globale sont basés sur des algorithmes de lancer de
rayons, des algorithmes avancés de radiosité, (la radiosité hiérarchique, progressive, clustering) ou sur des méthodes différentes comme les techniques de type Monte Carlo. La
méthode d’illumination à paralléliser dans ce travail est une approche de radiosité nouvelle présentée par Chatelier et Malgouyres [CM06] ; elle est basée sur une discrétisation
des surfaces en voxels. Cette méthode est fondée sur des notions de géométrie discrète.
L’espace peut être partitionné en des droites discrètes, chaque voxel appartient à une
et une seule droite. Pour une direction donnée, ces droites peuvent être vues comme
des listes de visibilité contenant des voxels classés par ordre de visibilité. Ces listes de
visibilité vont permettre des échanges d’énergie entre les voxels mutuellement visibles.
Dans ce chapitre, des notions de géométrie discrète sont expliquées. Ces notions sont
les bases pour comprendre l’algorithme séquentiel d’illumination globale que l’on cherche
à paralléliser au cours de cette thèse. L’algorithme séquentiel de Chatelier et Malgouyres
[CM06] est ensuite expliqué. Une étude de complexité spatiale et temporelle est notamment exposée et les temps de calcul sur différentes scènes sont présentés montrant la
nécessité d’avoir recours au parallélisme pour ce genre de traitement.
Finalement une étude de convergence de l’algorithme d’illumination est effectuée.
Elle consiste à faire varier le nombre d’itérations et de directions afin de voir les effets
de ces deux facteurs sur la vitesse de convergence de l’algorithme.
3.1
Notion de géométrie discrète
La géométrie discrète est un domaine de recherche assez récent qui a pour but de
représenter des modèles discrets. De nos jours, la géométrie discrète est utilisée dans le
55
Chapitre 3. Méthode d’illumination globale par voxels
56
domaine de l’infographie, l’imagerie médicale (superposition d’images, réalité virtuelle)
ou le traitement d’images (squelettisation, détection de contour, segmentation). La méthode d’illumination globale de Chatelier et Malgouyres discrétise les surfaces en voxels ;
cette méthode utilise des notions de géométrie discrète (les droites discrètes et le partitionnement de l’espace) pour le calcul de l’illumination.
3.1.1
Voxel
Un voxel est un élément de volume. Il représente l’analogie du pixel mais en trois
dimensions. Il peut être vue comme une cube unitaire identifié par les trois coordonnées
(x, y, z) de son centre et ayant les arêtes parallèles aux axes de coordonnées.
3.1.2
Adjacence
3.1.2.1
4-adjacence et 8-adjacence
Soient les points x et y ∈ Z2 , x est définit par (x1 , x2 ) et y est définit par (y1 , y2 ).
On définit les notions suivantes :
4-adjacence : y est 4-adjacent à x si |y1 − x1 | + |y2 − x2 | ≤ 1.
8-adjacence : y est 8-adjacent à x si max(|y1 − x1 | , |y2 − x2 |) ≤ 1.
Les Figures 3.1 et 3.2 montrent un exemple de points respectivement 4-adjacents et 8adjacent au point x. Ces points sont aussi appelés respectivement les 4 voisins et les 8
voisins du point x.
Soit E une partie de Z2 . Un point x est dit 4-adjacent (ou 8-adjacent) à E si et seulement
si x ∈
/ E et x est 4-adjacent (8-adjacent) à un point de E.
Fig. 3.1 – Le point x et ses 4 voisins
3.1.2.2
6-adjacence, 18-adjacence et 26-adjacence
Soient x (x1 , x2 , x3 ) et y (y1 , y2 , y3 ) deux points de Z3 . On définit les notions suivantes :
6-adjacence : x et y sont dits 6-adjacent s’ils partagent une face, c’est-à-dire si |x1 − y1 |+
|x2 − y2 | + |x3 − y3 | = 1.
57
18-adjacence : x et y sont dits 18-adjacent s’ils partagent une face ou une arête, c’est à
dire ils sont 26-adjacent et ont une coordonnée en commun.
26-adjacence : x et y sont dits 26-adjacent s’ils partagent une face ou une arête ou un
sommet, c’est à dire si max(|x1 − y1 | , |x2 − y2 | , |x3 − y3 |) = 1.
Les Figures 3.3, 3.4 et 3.5 montrent un exemple de points respectivement 6-adjacents,
18-adjacent et 26-adjacent au point x. Ces points sont aussi appelés les 6 voisins, les 18
voisins et les 26 voisins du point x.
Soit E une partie de ∈ Z3 . Un point x est dit 6-adjacent (ou 18-adjacent ou 26-adjacent)
à E si et seulement si x ∈
/ E et x est 6-adjacent (ou 18-adjacent ou 26-adjacent) à un
point de E.
3.1.3
Chemin et connexité
3.1.4
Un k-Chemin
Soit k = {4, 8} en 2D. Un k-chemin est une séquence finie d’éléments de points
P1 , ..., Pn ∈ Z2 , tel que pour i = 1, ..., n − 1, le point Pi+1 est k-adjacent au point Pi .
Soit k = {6, 18, 26} en 3D. Un k-chemin est une séquence finie d’éléments de points
P1 , ..., Pn ∈ Z3 , tel que pour i = 1, ..., n − 1, le point Pi+1 est k-adjacent au point Pi .
3.1.5
58
Composante connexe
Une partie A de Z2 ou Z3 est appelée k-connexe si et seulement si pour n’importe
quelle paire d’éléments de points P1 , P2 de A, il existe un k-chemin inclut dans A qui lie
le point P1 au point P2 .
3.1.6
Droites discrètes
3.1.6.1
Droites discrètes 2D
Les premiers objets étudiés en géométrie discrète furent les droites 2D discrètes.
La représentation des droites discrètes est différente de la représentation des droites
continues. Quand on veut discrétiser une droite continue, il faut prendre les points entiers
qui représentent cette droite. Une droite continue vue sur une grille peut passer par des
points entiers mais la plupart du temps, elle intersecte des arêtes de la grille (voir la
Figure 3.6). La définition de la droite discrète revient alors à définir le choix des points
entiers.
Fig. 3.6 – Une droite continue sur une grille. Cette droite peut intersecter plusieurs arêtes
de la grille
Reveillès en 1991 [Rev91] donne une définition fondamentale de la droite discrète 2D.
Une droite discrète ayant un vecteur directeur (a, b) peut être représentée par l’ensemble
des points :
(x, y) ∈ Z2 / 0 ≤ ax − by + µ < ω
(3.1)
où :
µ : représente la position de la droite
ω : représente l’épaisseur de la droite, ω caractérise aussi la connexité.
La Figure 3.7 montre un exemple d’une droite 2D et l’effet de la variation de ω sur
la droite.
Reveillès a établi que :
– si ω < max(|a| , |b|) alors la droite n’est pas 8-connexe,
– si ω = max(|a| , |b|) alors la droite est 8-connexe d’épaisseur minimale,
59
– si max(|a| , |b|) < ω ≤ |a| + |b| alors la droite est 8-connexe mais non 4-connexe
d’épaisseur minimale,
– si ω = |a| + |b| alors la droite est 4-connexe d’épaisseur minimale,
– si ω > |a| + |b| alors la droite est épaisse.
Une droite discrète est dite naïve (ω = max(|a| , |b|)) si elle est d’épaisseur minimal
pour être 8-connexe, et standard (ω = |a| + |b|)) si elle est d’épaisseur minimale pour
être 4-connexe.
3.1.6.2
Droites discrètes 3D
Isabelle Debled-Rennesson [DR95] a proposé la définition de la droite discrète 3D.
Etant donnée un vecteur de direction (a, b, c) ∈ Z3 avec a ≥ b ≥ c, la droite discrète 3D
peut être définie comme l’ensemble de points x, y, z ∈ Z3 tel que :

µ ≤ cx − az < µ + ω
(3.2)
µ0 ≤ bx − ay < µ0 + ω 0
Cette droite 3D représente l’intersection de deux plans discrets, chacun de ces plans
est le plongement de l’extrusion de deux droites discrètes 2D dans l’espace. Le cas a ≥
b ≥ c est considéré car les autres cas peuvent être déduit par symétrie.
Les paramètres ω et ω 0 ont une influence sur la connexité ;
– si ω < a ou ω 0 < a, la droite n’est pas connexe,
– si a ≤ ω ≤ a + c et a ≤ ω 0 ≤ a + b, la droite est 26-connexe,
– si a + c ≤ ω et a ≤ ω 0 < a + b, ou a + b ≤ ω 0 et a ≤ ω < a + c, la droite est
18-connexe,
– si a + c ≤ ω et a + b ≤ ω 0 , la droite est 6-connexe.
3.1.7
Autres objets discrets
Hormis les droites discrètes, il faut noter qu’il existe des paramétrisations d’autres
objets discrets telles les plans discrets [AAS97] les cercles, sphères, ellipses... et dont plus
de détails se trouvent dans [And00, AJ97, And03].
3.1.8
Partitionnement de l’espace
La droite discrète 3D discrète peut se définir en utilisant deux projections [DR95].
Pour l’algorithme d’illumination de [CM06], ces deux droites 2D sont suffisantes pour
reconstruire la droite 3D ; il y a parfois des bulles qui apparaissent, or ces bulles ne
gènent pas les résultats d’illumination (plus de détails se trouvent dans [Cha06]). La
Figure 3.8 montre un exemple d’une droite 3D discrète et ses deux projections. Si on
prend le cas d’une direction ayant un vecteur directeur v̂ = [a, b, c] avec a, b, c ∈ Z 3 où
! "
2
1
60
! "
2
1
!=1, "=2
!=1, "=1
! "
2
1
! "
2
1
!=1, "=4
!=1, "=3
2
(x, y) ∈ Z /µ ≤ ax − by < µ + ω
Fig. 3.7 – Une droite discrète 2D : différente épaisseur avec (a, b) = (2, 1)


10
7
3
z
y
x
Fig. 3.8 – Une droite 3D discrète ayant un vecteur directeur (10, 7, 3) et ses deux projections
61
a ≥ b ≥ c ≥ 0 ; les projections en 2D sont dans les plans (Oxy) and (Oxz) et donc ωbc
est nul. La droite discrète 3D est équivalente à l’ensemble des (x, y, z) ∈ Z2 tel que :

µab ≤ −bx + ay < µab + ωab
µ ≤ −cx + az < µ + ω
ac
ac
ac
Vue que a, b, c, ωab , ωac sont fixes, seule la position de la droite est choisie. L’ensemble
des voxels est représenté par L(µab , µac ). L’ensemble de droites 3D discrète Li,j représenté
par {Li,j }(i,j)∈Z2 = {L(i × ωab , j × ωac )}(i,j)∈Z2 peut être défini comme suit :
i × ωab ≤ −bx + ay < i × ωab + ωab
j × ωac ≤ −cx + az < j × ωac + ωac
i × ωab ≤ −bx + ay < (i + 1) × ωab
or
j × ωac ≤ −cx + az < (j + 1) × ωac
Etant donné un voxel, (x, y, z) ∈ Z3 , ce voxel appartient à une droite Li,j où i =
c and j = b −cx+az
c. i et j sont calculés à partir des coordonnés du voxel et du
b −bx+ay
ωab
ωac
vecteur directeur de la direction.
Donc étant donnée une direction, l’espace peut être partitionné en des droites 3D
discrètes de même direction. Un voxel (x, y, z) ∈ Z3 , appartient à une seule de ces droites
discrètes.
3.2
La Radiosité : définition et équation
La radiosité est définie comme l’énergie totale émise par un point d’une surface par
unité de surface. L’équation de la radiosité est une équation physique traduisant un
transfert d’énergie entre différents éléments. La forme générale de l’équation de radiosité
a été donnée au Chapitre 2, Section 2.4.1 :
Z
B(x) = Be (x) + ρd
0
cos θ cos θ
V (x, y)dy
B(y)
π kx − yk2
y∈ scène
(3.3)
Cette équation a été discrétisée dans [Mal02b]. L’équation discrétisée est la suivante :
B(x) = Be (x) + ρd
X
B(V (x, ~σ )) cos θ(x, V (x, ~σ ))A(~σ )
(3.4)
~
σ ∈D
L’explication de l’équation est : la quantité totale de lumière émise par un point
est égale à la propre émittance du point comme source de lumière (le terme Be (x)) et
quelque ré-émission que le point reçoit de son environnement (la somme). La signification
des différents termes de cette équation discrète est la suivante :
– Be (x) : la propre émittance du point en tant que source lumineuse ;
62
Fig. 3.9 – Etant donné une direction ~σ et un point x, V (x, y) est une fonction de visibilité
retournant le premier voxel y rencontré à partir de x dans la direction ~σ . θ représente
l’angle entre la normal au point x et la droite partant de x dans la direction ~σ
– ρd : paramètre de la capacité de réémission d’un élément. Un point émet une
fraction de la lumière qu’il reçoit ;
– D : l’ensemble des directions dans l’espace ;
– V (x, ~σ ) : Une fonction de visibilité qui retourne le premier point rencontré à partir
de x dans la direction ~σ (voir la Figure 3.9) ;
– B(V (x, ~σ )) : la radiosité du premier point rencontré à partir de x dans la direction
~σ ;
– A(~σ ) : Une fraction de l’angle solide associée à la direction ;
– cos θ(x, V (x, ~σ )) traduit l’importance de l’incidence dans le modèle d’éclairement
diffus.
3.3
Résolution de l’équation : méthode quasi-linéaire
Une première résolution de l’équation (3.4) de radiosité a été donnée par Malgouyres
[Mal02a]. La scène est discrétisée (subdivisée en voxels) en n’encodant des voxels que
sur les surfaces. Ensuite la résolution de l’équation se répartie en deux étapes :
– la première étape consiste à calculer pour tout (x, ~σ ) le voxel V (x, ~σ ). Ce calcul est
basé sur le lancer de rayon discret qui représente le rayon par une droite discrète ;
cette droite est parcouru utilisant l’algorithme de lancer de rayon depuis son point
de départ jusqu’à arriver à un voxel de l’objet. Une optimisation du lancer de
rayon usuel, utilisant des bounding box stockées dans un octree est adoptée ; cette
optimisation a permis de simplifier les tests d’intersection d’un rayon avec tous les
objets de la scène ;
– La deuxième étape est la résolution de l’équation par des méthodes itératives
convergente (Chapitre 2, Section 2.4.3.1) comme la méthode de Jacobi ou GaussSeidel).
Cette première résolution a une complexité raisonnable mais en pratique sur des scènes
3D le coût est assez important. Chatelier et Malgouyres [Cha06] ont trouvé un moyen
d’améliorer cette résolution : ils ont proposé un algorithme quasi-linéaire de résolution
63
Fig. 3.10 – Le parcours des voxels dans un ordre quelconque pour les mettre en place
dans les listes auxquelles ils appartiennent ne garantit pas la visibilité entre les voxels.
Un tri de chacune des listes en terme de visibilité est nécessaire
dont les détails seront expliqués dans les sections suivantes.
3.3.1
Partitionnement de l’espace et visibilité
L’idée de partitionnement de l’espace en droites 3D et l’appartenance d’un voxel à
une et une seule droite permet de résoudre le problème de visibilité. Etant donné une
direction ~σ , un tableau bi-dimensionel peut être créé. Ce tableau aura pour indice i, j, où
(i, j) représente l’indice d’une liste Li,j de l’espace. Les voxels de la scène sont parcourus,
le (i, j) de chaque voxel est trouvé et le voxel est stocké dans la liste (i, j) à laquelle il
appartient. Or la mise en place des voxels dans les listes auxquelles ils appartiennent
ne garantit pas la visibilité entre les voxels d’une même liste (Figure 3.10). Il faut trier
les listes des voxels pour garantir la visibilité. Or ce tri est coûteux surtout quand les
listes sont denses (contenant beaucoup de voxels). Dans [CM06] une manière permettant d’éviter ce tri est explicitée. En parcourant les voxels avec un ordre particulier,
(l’ordre lexicographique (Section 3.3.2)), il est possible d’éviter le tri des listes et de
mettre les voxels directement dans leur ordre correct (l’ordre de visibilité) dans la liste
correspondante.
3.3.2
Ordres lexicographiques
Comme il a été noté dans la Section 3.3.1, il est possible d’éviter le tri des voxels
par ordre de visibilité en choisissant un certain ordre particulier dans le parcours des
voxels. Cet ordre est l’ordre lexicographique (Figure 3.11). En général il y a 48 ordres
lexicographiques. Parmi ces 48, 24 sont utiles, les autres étant simplement les ordres
opposés. En plus ces 24 peuvent se réduire à 4 ((x ↑ y ↑ z ↑),(x ↑ y ↓ z ↓),(x ↑ y ↑ z ↓
64
Fig. 3.11 – Le parcours des voxels dans l’ordre lexicographique garantit la visibilité entre
les voxels
),(x ↑ y ↓ z ↑)) en utilisant les symétries. Par exemple les ordres (x ↑ y ↑ z ↑) est le
même que (y ↑ x ↑ z ↑) donc le placement de y avant x ou x avant y, ne change rien.
Notons que le choix de l’ordre lexicographique dépend du vecteur directeur de la
direction. La Figure 3.12 illustre un exemple du choix de l’ordre lexicographique. Pour
une direction ayant un vecteur directeur v~1 , l’ordre lexicographique choisi est (x ↑ y ↓
z ↑) et pour v~2 , l’ordre lexicographique choisi est (x ↓ y ↑ z ↓) qui est le réciproque de
(x ↑ y ↓ z ↑).
3.3.2.1
Discrétisation de la scène
La discrétisation de la scène en voxels est effectuée en utilisant un algorithmes de
discrétisation mais cela se situe hors du cadre de cette thèse. Plus de détails sur les
algorithmes adoptés pour la discrétisations se trouvent dans [Cha06] à la page 80.
Fig. 3.12 – Le choix de l’ordre lexicographique dépend du vecteur direction de la direction. Si le vecteur directeur est v~1 , l’ordre lexicographique choisit est (x ↑ y ↓ z ↑), et si
c’est v~2 , l’ordre lexicographique choisit est (x ↓ y ↑ z ↓)
3.3.3
65
Calcul de l’ensemble des directions
Dans l’équation (3.4), la somme est effectuée autour d’un ensemble D des directions
~σ . Cet ensemble de directions doit être assez isotrope et paramétré de façon à générer
plus ou moins de directions. Une sphère discrète convient bien pour la génération de ses
direction ; le rayon de la sphère détermine le nombre de directions (Figure 3.13).
Fig. 3.13 – L’ensemble de directions est construit à partir d’une sphère discrète. Le rayon
de la sphère contrôle le nombre de directions
3.3.4
Étapes de l’algorithme
Pour résoudre l’équation (3.4) d’illumination, Chatelier et Malgouyres [CM06] utilise
une méthode itérative convergente qui est la méthode de Gauss-Seidel necessitant plusieurs itérations afin d’obtenir une convergence vers la bonne solution d’illumination. La
résolution complète de l’équation nécessite le calcul de l’ensemble des directions (Section 3.3.3).
L’algorithme illustrant les différentes étapes du calcul de l’illumination est montré
en Algorithme 3.1. Notons que les étapes les plus importantes du point de vue calcul
de cet algorithme sont la mise en place des voxels et la propagation de la lumière dans
les listes. Etant donnée une direction, la mise en place des voxels dans les listes consiste
à parcourir les voxels de la scène selon l’ordre lexicographique approprié, trouver pour
chaque voxel la liste (i, j) à laquelle il appartient et insérer le voxel en queue de cette liste
(i, j). La propagation de la lumière dans les listes consiste à échanger la lumière entre
les voxels voisins en terme de visibilité ; pour cela une propagation avant et arrière est
effectuée pour assurer un échange réciproque entre deux voxels voisins. La Figure 3.14
montre un exemple de la propagation de la lumière dans les listes.
66
Fig. 3.14 – La propagation de la lumière dans les listes nécessite un échange mutuel de
lumière entre les voxels appartenant à une même liste et voisins en terme de visibilité
Préparer les 4 ordres lexicographiques
Construire l’ensemble de directions
Pour(chaque itération)
Pour(chaque direction)
Sélectionner l’ordre lexicographique approprié
Pour (chaque voxel)
mettre le voxel en fin de la liste à laquelle il appartient
Fin Pour
Pour (chaque liste)
Propager la lumière dans la liste
Fin Pour
Remise à zéro des listes
Fin Pour
Fin Pour
Algorithme 3.1 – Algorithme quasi-linéaire du calcul de l’illumination
3.3.5
Complexités
3.3.5.1
Complexité temporelle
67
Du point de vue complexité, si on note N le nombre de voxels dans la scène, I le
nombre d’itérations et D le nombre de directions, la complexité de l’algorithme d’illumination est
4 × O(N log N ) + I × D × (O(N ) + O(N )) = O(N log N ) + O(I × D × N )
Le premier terme 4 × O(N log N ) est le temps de trier les voxels par ordre lexicographique. Puisque le nombre d’ordres lexicographiques est limité (4 ordres lexicographiques), les quatre tris des voxels sont considérés comme un pré-calcul ; les voxels
sont triés une fois au début avant de commencer l’algorithme de calcul de l’illumination
globale et les quatre vecteurs triés sont gardés en mémoire.
Le deuxième terme O(I ×D×N ) est le temps du calcul de l’illumination. Il représente
la mise en place et la propagation de la lumière dans les listes. Ce temps dépend de 3
variables :
– I est le nombre d’itérations qui est nécessaire pour la convergence vers la bonne
solution d’illumination ; I est généralement bornée 4 à 6 itérations sont suffisantes
pour des grandes scènes ;
– D est le nombre de directions. Cette constante est indépendante du nombre de
voxels, elle dépend de l’intensité des sources lumineuses. Elle est augmentée pour
éviter les effets d’aliasing quand les sources ont une large intensité lumineuse ;
– N est le nombre de voxels qui dépend des scènes et pourra augmenter largement
pour des grandes scènes.
3.3.5.2
Complexité spatiale
Soit N le nombre de voxels de la scène, ces voxels sont stockées en mémoire en
O(N ). Dans une direction, l’ensemble de toutes les listes contient une référence unique à
chaque voxel, si bien que la complexité spatiale de cet ensemble est de O(N ). Les ordres
lexicographiques précalculés sont stockés dans des tableaux et coûtent O(N ).
Un tableau bi-dimensionnel est utilisé pour stocker les listes. Le nombre de listes est
lié au carré de la largeur de la scène.
√ Seules les surfaces des objets étant discrétisées,
cette largeur est en moyenne en O( N ). O(N ) listes sont donc nécessaires. Les listes
sont remises à zéro à chaque direction, le coût de stockage n’augmente donc pas au fur
et à mesure du déroulement de l’algorithme.
Au final, la complexité spatiale est un O(N ) qui peut être confondu avec le O(N )
nécessaire pour stocker les données à traiter.
68
(a)
(b)
(c)
Fig. 3.15 – (a) Une scène 3D avant le calcul de l’illumination. (b) Représentation voxels
de la scène, pour le calcul de l’illumination. (c) Scène 3D affichée avec les données
calculées de l’illumination
3.4
69
Résultats
La Figure 3.15(a), reprise de [Mal02b], permet la visualisation d’une scène avant le
calcul de l’illumination. Cette scène est discrétisée en voxels (Figure 3.15(b)) ensuite le
calcul de l’illumination est effectuée. Le résultat visuel final du calcul de l’illumination
est montré en Figure 3.15(c) qui reflète l’éclairage final de la scène.
Concernant les temps de calcul, l’algorithme d’illumination est testé sur différentes
scènes prenant différent nombres de directions permettant ainsi de voir la variation du
temps en fonction du nombre de directions. La Figure 3.16 montre le temps séquentiel
du calcul d’illumination pour différents nombre de directions ; les tests sont effectués
sur une scène d’un salon contenant un million sept mille voxels avec 6 itérations. La
Figure 3.17 montre le même test effectué sur la scène du salon, se répéter sur trois
différentes scènes. La première scène est la scène d’une cabine, la deuxième est la scène
d’une salle de travail et la troisième est la scène d’une église ; ces trois scènes contiennent
respectivement 3,1 millions, 3,25 millions et 3,5 millions voxels.
Les résultats montrent que les quatre tris pré-calculés des voxels et qui ont une
complexité 4 × O(N log N ), N étant le nombre de voxels, n’ont aucune influence sur les
résultats, c’est toujours le coup linéaire qui domine. Il est clair aussi que le temps varie
d’une manière linéaire par rapport au nombre de directions.
1000
Salon
Temps (minutes)
800
600
400
200
0
2000
4000
6000
8000
10000
12000
Nombre de directions
Fig. 3.16 – Temps de calcul en fonction du nombre de directions de l’algorithme séquentiel
d’illumination pour la scène d’un salon
70
Cabine
Eglise
Salle de travail
1200
Temps (minutes)
1000
800
600
400
200
0
1000
2000
3000 4000 5000 6000
7000
8000
Fig. 3.17 – Temps de calcul en fonction du nombre de directions de l’algorithme séquentiel
d’illumination pour trois différentes scènes
3.5
Étude de convergence
Dans l’algorithme séquentiel d’illumination globale ainsi que dans les parallélisations
de cet algorithme [CM06, ZCFM06, ZFM06] qui seront étudiées en détails dans les
chapitres suivant, la méthode itérative de Gauss-Seidel est utilisée pour résoudre le
système d’équations.
La plupart des algorithmes d’illumination par radiosité utilisent des méthodes itératives afin de résoudre le système d’équations, car les méthodes directes sont coûteuses
en terme de complexité. Les méthodes itératives ne calculent pas une solution exact
mais une solution approchée avec une certaine erreur [RF98]. La résolution du système
d’illumination avec la méthode de Gauss-Seidel, nécessite plusieurs itérations afin d’obtenir une convergence vers la bonne solution d’illumination. Or l’équation d’illumination
à résoudre, équation (3.4), ne dépend pas seulement du nombre d’itérations, mais elle
contient aussi un facteur de direction. Le facteur de direction est calculé en utilisant une
sphère discrète qui génère un ensemble de directions. Le nombre de directions dépend du
rayon de la sphère discrète ; un rayon plus élevé génère plus de directions [Mal02b, Cha06]
qu’un rayon moins élevé. En terme de précision des résultats d’illumination, il est intéressant de regarder l’influence des deux facteurs, le nombre d’itérations et le nombre de
directions, sur la convergence de l’algorithme vers la bonne solution d’illumination. Les
71
tests de convergence consistent à fixer le nombre de directions et à faire varier le nombre
d’itérations afin de voir l’influence de ce facteur sur la convergence. De même, ces tests
consistent à fixer le nombre d’itérations et à faire varier le nombre de directions. Le
nombre de directions est définit par rapport à la sphère discrète en prenant en compte
toutes les directions ou seulement un pourcentage de ces directions choisies d’une manière aléatoire. Les sections qui viennent montrent les erreurs obtenues en changeant le
nombre de directions ainsi que le nombre d’itérations en regardant leurs effets vers la
convergence de la solution d’illumination.
10
10
Erreur moyenne (toutes les directions)
Erreur maximale (toutes les directions)
Erreur moyenne (80% des directions)
Erreur maximale (80% des directions)
1
1
0.1
Erreur
Erreur
0.1
0.01
0.01
0.001
0.001
0.0001
0.0001
1e−005
1e−005
0
30
60
90
120
150
180
Rayon de la sphère discrète
210
240
270
300
Fig. 3.18 – Effet de la variation du rayon
de la sphère discrète sur l’erreur. Pas
d’Epsilon
3.5.1
0
30
60
90
120
150
180
210
240
270
300
Fig. 3.19 – Effet de la variation du
rayon de la sphère discrète sur l’erreur.
Epsilon=10−5
Scène de référence
L’étude de convergence requiert un calcul séquentiel exact d’illumination accompli sur
une scène spécifique, cette scène sera appelée “scène de référence” car elle sera considérée
comme une scène fournissant le résultat exact d’illumination. L’étude de convergence de
l’algorithme d’illumination reviendra alors à calculer l’illumination de la scène variant le
facteur de direction ou d’itération, et mesurer l’erreur de la scène obtenue par rapport
à la “scène de référence”.
Le calcul de cette “scène de référence”, demande une prise d’un nombre de directions
relativement large afin de garantir un calcul exact d’illumination ainsi qu’un nombre
d’itérations suffisant permettant de garantir la convergence vers une solution exact d’illumination, avec la moindre erreur possible.
3.5.2
Mesure d’erreur
Pour une scène donnée, la première étape est le calcul de la “scène de référence”.
La valeur d’illumination d’un voxel v de cette scène est dénotée comme l’“illumination
72
exacte”. Ensuite pour cette même scène, le nombre de directions est fixé (rayon de la
sphère discrète) ainsi que le nombre d’itérations et la valeur d’illumination des voxels est
calculée ; la valeur d’illumination d’un voxel v de la scène sera notée l’“illumination courante”. Une erreur entre l’“illumination exacte” et l’“illumination courante” pour chacun
des voxels est calculée. Cette erreur permet de voir l’influence de la variation du nombre
de directions et du nombre d’itérations sur le résultat d’illumination.
Dans l’algorithme d’illumination [CM06], les voxels d’une scène renferme plusieurs
informations (émittance, reflectance, coefficient de réflexion, etc...). Ces informations
sont utilisées pour le calcul d’illumination. Or l’étude de convergence requiert une seule
information ; c’est la valeur d’illumination (RGB) de chacun des voxels de la scène. La
première erreur à calculer est l’erreur moyenne :
P
nbV oxels
Erreur
où Erreur = |fi − gi |, fi et gi sont respectivement
erreur moyenne = i=0nbV oxels
l’“illumination courante” et l’“illumination exacte” d’un voxel i. nbV oxels est le nombre
de voxels de la scène.
L’erreur maximale, représentant la valeur maximale des erreurs (RGB) d’illumination
des voxels de la scène. L’erreur maximale est importante afin de savoir la valeur maximale
des erreurs des voxels de la scène.
Les deux erreurs erreur moyenne et erreur maximale, considère l’Erreur comme
i|
. La mesure
étant |fi − gi |. Or il est aussi important de mesurer l’erreur réelle |fig−g
i
de l’erreur réelle peut être problématique dans certains cas, spécialement si les valeurs
d’illumination traitées sont petites. Dans ces cas, pour un voxel donné, si l’“illumination
exacte” est relativement petite, l’erreur réelle peut atteindre une valeur élevée, sans que
f et g de ce voxel ne soient tellement différents. Afin de résoudre un tel problème, une
notion d’epsilon est introduite :
i|
si gi > epsilon . En variant epsilon il est
erreur réelle (avec epsilon) = |fig−g
i
possible de diminuer l’influence des valeurs d’illumination très faibles qui parfois génèrent
des erreurs relatives importantes sans justification du point de vue de la précision.
3.5.3
Résultats
Les tests de convergence sont effectués pour la scène d’une cabine composée de 3.1
million de voxels. Les Figures 3.18, 3.19 et 3.20 montrent les résultats de convergence en
utilisant 6 itérations et en variant le rayon de la sphère discrète. Une variation du rayon
de la sphère discrète implique une variation du nombre de directions. Au début toutes
les directions générées par la sphère sont prises en compte, puis un certain pourcentage
de ces directions, prises d’une façon aléatoire, est considéré. 80 percent indique que
seulement 80 pourcent de ces directions sont prises. Les résultats montrent que l’erreur
diminue quand le rayon de la sphère discrète augmente, donnant plus de précision aux
résultats. Il a été remarqué à travers les résultats, qu’il y a un risque de diminution
de la rapidité de convergence en prenant, d’une manière aléatoire, un pourcentage (80
pourcent) des directions générées par la sphère discrète. Il est clair en regardant les
73
résultats que le fait de prendre une partie des directions n’est pas suffisant et il est
préférable de prendre l’ensemble complet de directions.
10
1
0.01
Erreur
Erreur
1
0.0001
1e−006
0.1
1e−008
1e−010
0.01
0
30
60
90
120
150
180
210
240
270
300
rayon de la sphère discrète sur l’erreur.
Epsilon=10−7
2
3
4
5
6
Nombre d’itérations
7
8
9
nombre d’itérations sur l’erreur. Pas
d’Epsilon
les Figures 3.21, 3.22 et 3.23 montrent l’erreur obtenue en fixant le rayon de la
sphère discrète à 55 et variant le nombre d’itérations. Il est possible de voir que quand
le nombre d’itérations augmente, l’erreur diminue d’une manière linéaire. Cette chute de
l’erreur est plus rapide que celle obtenue en augmentant le nombre de directions. Cela
montre la grande importance du nombre d’itérations sur la convergence de l’algorithme
d’illumination. Il est sûr que le nombre de directions a une influence remarquable, mais
c’est surtout le nombre d’itérations qui a une plus grande influence sur la convergence.
100
100
10
1
1
0.1
Erreur
Erreur
0.01
0.0001
0.01
0.001
1e−006
0.0001
1e−008
1e−005
1e−010
1e−006
2
3
4
5
6
7
8
9
Fig. 3.22 – Effet de la variation
du nombre d’itérations sur l’erreur.
Epsilon=10−5
2
3
4
5
6
7
8
9
Fig. 3.23 – Effet de la variation
du nombre d’itérations sur l’erreur.
Epsilon=10−7
3.6
74
Conclusion
L’algorithme d’illumination présenté dans ce chapitre est quasi-linéaire, mais c’est
la constante I × D × N (Section 3.3.5.1) qui induit un temps de calcul important pour
de grandes scènes. C’est là où la parallélisation joue son rôle afin d’améliorer le temps
de calcul pour des grandes scènes (millions de voxels) contenant de sources intenses et
nécessitant donc un grand nombre de directions et d’itérations.
L’étude de convergence de l’algorithme d’illumination montre les effets de variation
des deux facteurs le nombre d’itérations et le nombre de directions sur la convergence de
l’algorithme. Le nombre d’itérations même s’il est bornée, est un facteur très important
sur la convergence. En incrémentant ce facteur, il est possible de minimiser largement
l’erreur. Concernant le facteur de directions, celui-ci a aussi une grande influence sur la
convergence et son incrémentation diminue l’erreur. Les résultats des tests sur le facteur
de directions ont montrés qu’il est préférable en générant un ensemble de directions à
travers une sphère discrète de prendre tout l’ensemble de directions et non une partie
de cet ensemble. Ce facteur a une influence importante sur la convergence mais son
influence est moins directe que le facteur d’itérations qui lui, permet une chute rapide
de l’erreur.
Il faut noter que l’algorithme d’illumination par voxels [Cha06] est plus coûteux en
temps de calcul que les algorithmes de radiosité par patchs ou les algorithmes de lancer de rayons. Cela est dû au fait que les patchs, qui peuvent être de tailles variables
et dynamiques, sont souvent mieux adaptés à la représentation des grandes surfaces
que les voxels, qui sont de tailles identiques. Pour des scènes contenant trop de détails, les voxels doivent être petits pour permettre plus de précision dans le calcul, ce
qui augmente considérablement le temps de calcul. Les chapitres qui suivent présentent
différentes parallélisations qui vont améliorer le temps de l’algorithme séquentiel et minimiser la mémoire. Les deux premières parallélisations sont la parallélisation locale et la
distribution du calcul. Elles ne distribuent pas les données et nécessitent une duplication
des voxels sur les noeuds des grappes pour le calcul d’illumination. Les deux autres parallélisations distribuent les données et permettent alors le traitement de grandes scènes
qui n’entrent pas en mémoire.
Notons finalement qu’une version étendue de cet algorithme du cas diffus idéal au
cas BRDF a été proposée par Pierre Chatelier [CM07]. Ces extensions seront parallélisées dans un prochain travail. Une autre version de l’algorithme est aussi en cours par
un doctorant (Lukasz Piwowar) ; cette version tend à réduire le nombre de voxels en
offrant un affichage non aliasé diminuant largement le temps de calcul. La combinaison
de l’algorithme [CM06] avec celui de Lukasz Piwowar permettra probablement d’offrir
un algorithme séquentiel compétitif par rapport aux autres algorithmes d’illumination
globale comme la radiosité par patchs ou le photon mapping.
Chapitre 4
Parallélisation locale et distribution du
calcul
L’algorithme séquentiel de calcul de l’illumination globale nécessite une augmentation du nombre de directions quand l’intensité des sources lumineuses augmente. Cet
algorithme a montré des temps de calcul élevés à la fois quand le nombre de directions
augmente et quand le nombre de voxels augmente. Cela fait appel au calcul parallèle qui
constitue une solution pour améliorer les performances en temps.
Dans ce chapitre, une présentation des machines utilisées pour tester les différentes
parallélisations réalisées dans ce mémoire est effectuée.
Ce chapitre traite deux parallélisations distinctes de la méthode d’illumination globale effectuées sur un cluster localisé au LAIC, comprenant des noeuds à mémoire distribuée. Nous avons utilisé le transfert de messages comme moyen de communication
entre les noeuds. Les deux parallélisations ne distribuent par les données mais les dupliquent sur les noeuds. La première parallélisation est locale : elle consiste à utiliser la
programmation multithreadée utilisant les threads pour effectuer des activités en parallèle. Le travail avec les threads est efficace grâce à la structuration physique des noeuds
constitués de bi-processeurs. La deuxième parallélisation est une distribution du calcul
qui répartit l’ensemble de directions entre les noeuds permettant ainsi un traitement
en parallèle des directions. Ces deux approches sont détaillées et testées sur différentes
scènes montrant des résultats très encourageants.
4.1
Description des machines utilisées pour le calcul
parallèle
Les machines utilisées pour tester les différentes parallélisations au cours de cette
thèse, sont des grappes de stations de travail (cluster of workstations), des machines
MIMD à mémoire distribuée ou multi-ordinateurs (voir Section. 1.4.1.1). Chaque processeur dispose de sa propre mémoire privée. L’espace d’adressage est physiquement
75
Chapitre 4. Parallélisation locale et distribution du calcul
76
distribué. La communication entre les processeurs se fait à travers le transfert de messages via le réseaux d’interconnexion ; la librairie MPI est utilisée pour le transfert de
messages.
Deux clusters sont utilisées pour les tests, le cluster localisé au LAIC (cluster Laic)
et le cluster localisé à l’ISIMA (cluster Isima). Une présentation de ces deux grappes est
décrite ci-dessous.
4.1.1
Cluster Isima
Les grappes de stations de travail se compose de 15 machines, 1 machine maître
(noeud de management) et 14 noeuds de calcul.
Ces noeuds sont des machines bi-processeurs Xeon hyperthreadés 2.8 GHz, ayant
chacune 2 Go de RAM et munie d’un disque 73 Go SCSI.
4.1.2
Cluster Laic
Les grappes de stations de travail se compose de 11 machines, 1 machine maître
(noeud de management) et 10 noeuds de calcul.
Ces noeuds sont des machines bi-processeurs Xeon hyperthreadés 2.67 GHz, ayant
chacune 2 Go de RAM et munie d’un disque 73 Go SCSI.
Fig. 4.1 – Quatre activités exécutées en séquentiel
4.2
4.2.1
Parallélisation locale
Threads et programmation multithreadée
La programmation multithreadée est une programmation qui utilise les threads et
qui permet d’accomplir des activités en parallèle. Blaess [Bla00] traduit le mot thread
par une “file d’exécution”, c’est-à-dire un déroulement particulier du code du programme
qui se produit parallèlement à d’autres entités en cours de progression. Les threads sont
caractérisés par un même espace d’adressage ce qui leur permet de partager des données.
77
Fig. 4.2 – Quatre activités exécutées en parallèle en utilisant les threads. Théoriquement,
le temps final est le temps de l’activité la plus longue
Dans une application donnée, des threads sont crées selon le nombre d’activités à
accomplir et chacun de ces threads est responsable d’une certaine activité. La programmation multithreadée a pour avantage d’aider à augmenter la parallélisation. Dans une
application non threadée, le temps pour accomplir quatre activités est la somme des
temps nécessaires pour accomplir chacune de ces activités (Figure 4.1). Or dans une
application multithreadée, on peut imaginer le temps pour accomplir quatre activités
comme le temps de la plus longue activité (Figure 4.2). En pratique c’est pas toujours
le cas, l’efficacité des threads est très liée au système utilisé (bi-processeur multithreadé
ou hyper-threadé...) et qui parfois limite l’efficacité des threads. Un même travail multithreadé effectué sur des mono-processeurs est plus lent que s’il est achevé sur des biprocesseurs ; cela vient du fait que les bi-processeurs sont capables de lancer des threads
sur chacun des deux processeurs alors que dans une application mono-processeur tous
les threads sont lancés sur un même processeur.
Les threads peuvent aider à maximiser la parallélisation. Ils peuvent exécuter plusieurs activités en parallèle. Prenons par exemple le cas d’un programme où un thread
donné a besoin d’attendre un système de finir. Pendant ce temps d’attente, les autres
threads peuvent accomplir plusieurs travaux accélérant ainsi le temps total d’exécution
du programme. Il faut noter que les threads ne sont intéressants que dans les applications comprenant plusieurs tâches qui peuvent s’exécuter en parallèle. La programmation
avec les threads est complètement inutile si les opérations sont dépendantes et si une
opération doit attendre l’opération précédente pour pouvoir s’exécuter.
78
L’implémentation des threads sous linux (norme POSIX) peut se faire sous deux
possibilités : l’implémentation dans l’espace noyau et l’implémentation dans l’espace
utilisateur. Dans notre travail l’implémentation est effectuée dans l’espace utilisateur,
utilisant la bibliothèque POSIX de linux référencée par POSIX threads ou Pthreads.
4.2.2
Utilisation des threads dans la méthode d’illumination globale
La méthode d’illumination globale en séquentiel, comprend deux étapes essentielles,
la distribution des voxels dans les listes et la propagation de la lumière dans les listes,
qui sont coûteux en temps de calcul et qui se répètent à chaque direction. Ces deux
étapes peuvent être partagées en plusieurs sous tâches indépendantes qui sont distribuées
parmi les threads pour être traitées en parallèle. Les sections qui viennent expliquent
l’utilisation des threads dans chacune de ces deux étapes du calcul d’illumination globale.
4.2.2.1
Distribution des voxels dans les listes
La distribution des voxels dans les listes consiste à parcourir les voxels dans l’ordre
lexicographique, trouver le i et j (partition de l’espace en droites) de chacun des voxels
selon la direction (Figure 4.3) et insérer le voxel selon son (i, j), dans la liste à laquelle
il appartient (voir Chapitre 3). Ce travail n’est pas coûteux pour une petite scène mais
pour traiter des grandes scènes formées de millions des voxels, il devient important. La
diminution du coût de ce calcul est possible grâce à l’utilisation des threads : l’ensemble
de voxels peut être réparti sur les threads pour se traiter en parallèle.
Pour une direction donnée, le vecteur de voxels (Figure 4.3) représentant les voxels
de la scène est distribué parmi les threads. Cette distribution consiste à donner à chacun
des threads une partie plus ou moins équitable de voxels afin d’équilibrer la charge de
travail pour tous les threads. Cela évite les temps d’attentes causés par des threads qui
ont fini le traitement de leurs tâches avant d’autres qui ont plus de travail à faire. Une
fois les voxels répartis sur les threads, chaque voxel est inséré dans la liste à laquelle
il appartient en respectant le parcours des voxels dans l’ordre lexicographique. L’ordre
lexicographique maintient la visibilité entre les voxels lors de leur mise en place dans
les listes de visibilité. Cet ordre est donc important et ne doit pas être bouleversé faute
d’influence sur la visibilité des voxels. Le fait de distribuer les voxels sur les threads afin
d’être traités en parallèle risque de ne pas maintenir l’ordre lexicographique lors de la
mise en place des voxels dans leurs listes. La Figure 4.4 montre un exemple d’un vecteur
de voxels rangés dans un certains ordre lexicographique et distribués sur trois threads.
Quand les threads démarrent leur travail parallèle, les voxels “e”, “g” et “i” ayant le même
(i, j) risquent de ne pas être mis dans le bon ordre de visibilité si le thread2 met son
voxel “g” avant le voxel “e” du thread1 alors que les données du thread2 viennent après
ceux du thread1 dans l’ordre lexicographique (le voxel “e” vient avant le voxel “g” dans
l’ordre lexicographique).
79
Fig. 4.3 – Des voxels classés dans l’ordre lexicographique et leur (i, j) pour une direction
donnée
Fig. 4.4 – Distribution des voxels sur trois threads. Le risque de perdre le bon ordre des
voxels si thread2 met son voxel “g” avant le voxel “e” du thread1, alors que “g” vient après
“e” dans l’ordre lexicographique
La solution à ce problème consiste à créer une structure de données distincte pour
chacun des threads dans laquelle le thread met toutes ses listes de visibilité. La Figure 4.5
montre un exemple de création de trois structures de données distinctes pour la mise en
place des listes de visibilité pour chacun des trois threads. Cela évite les accès concurrents
des threads aux listes de visibilité et permet aux threads une construction des listes sans
tenir compte d’aucune contrainte de priorité parmi les threads.
4.2.2.2
Propagation de la lumière dans les listes
Regroupement des structures
Dans l’étape de mise en place des voxels dans les listes, chaque threads insère ses
voxels un par un dans leurs listes correspondantes, dans la structure de données destinée
au thread en question. Après cette étape, une propagation de la lumière dans les listes
80
Fig. 4.5 – Création d’une structure de données distincte pour chacun des threads dans
laquelle le thread met ses listes de visibilité
est nécessaire pour le calcul de l’illumination. La propagation de la lumière dans les listes
consiste à propager la lumière entre les voxels voisins en terme de visibilité appartenant
à une même liste. Or les listes de visibilité construites au cours de la mise en place des
voxels ne sont pas des listes complètent car des structures de données distinctes sont
créées pour chacun des threads. Un regroupement des voxels appartenant à une même
liste mais présents sur une structure de donnés distincte est nécessaire ; cela permet
d’obtenir une seule structure contenant toutes les listes de visibilité de la scène. Une
manière de faire le groupement consiste à regrouper les voxels appartenant à une même
liste en suivant le même parcours de voxels effectué au moment de la construction des
listes par les threads, tenant compte ainsi de l’ordre des structures de données. Par
exemple dans la Figure 4.6, les voxels du thread1 se situent avant thread2 dans l’ordre
lexicographique et ceux du thread2 se situent avant ceux du thread3. Cela indique qu’il
faut partir des listes du thread1, insérer en queue de liste tous les voxels d’une même
liste localisés sur les structures de données construites par les autres threads. Les voxels
sont rajoutés en queue de liste afin de respecter l’ordre lexicographique des voxels.
Une fois le regroupement effectué, les listes de voxels sont partagées entre les threads
pour être traitées en parallèle.
La distribution des listes entre les threads consiste à donner à chaque thread une
partie des listes. Or cette distribution doit être convenable. Une distribution des listes
en divisant le nombre de listes par le nombre de threads n’est pas une bonne distribution
car certaines listes sont vides ainsi que certaines listes contiennent plus de voxels que les
autres ce qui obligera les threads qui ont moins de voxels à attendre les autres threads
ayant plus de voxels. Afin d’obtenir une bonne minimisation de temps, il ne suffit pas
de diviser le nombre total des listes sur le nombre de processeurs, mais il faut compter
le nombre des voxels dans chaque liste et donner à chaque processeurs un nombre de
81
listes contenant un nombre de voxels plus ou moins égal. C’est alors en parcourant les
listes comptant le nombre de voxels dans chaque liste qu’une distribution des listes sur
les threads, équitable en charge, est achevée.
Après le regroupement et la distribution des listes entre les threads, les threads
peuvent commencer l’étape de propagation de la lumière dans les listes (Figure 4.7).
Cette étape est simple et comme dans le calcul séquentiel, elle consiste à faire un échange
mutuel de lumière entre les voxels voisins en terme de visibilité. Malgré la possibilité du
regroupement, le coût de regroupement reste élevé pour de grandes scènes contenant des
listes denses en nombre de voxels. Le regroupement a diminué l’efficacité des threads et
une manière de l’éviter est alors souhaitable.
Fig. 4.6 – Regroupement des données des threads
Eviter le regroupement
L’étape du regroupement consiste à regrouper les voxels d’une même liste pour
construire des listes complètent qui seront ensuite distribuées entre les threads qui vont
y propager la lumière. Le regroupement est coûteux en temps de calcul, une manière de
82
Fig. 4.7 – Après le regroupement des listes, les listes sont distribuées entre les threads
qui vont y propager la lumière
Fig. 4.8 – Le regroupement peut être évité. Chacun des threads effectue des échanges
de lumières entre les voxels consécutifs d’une même liste. Une étape supplémentaire est
rajoutée pour échanger la lumière entre les voxels appartenant à une même liste mais
présents sur une structure de données d’un thread distinct
l’éviter est possible. Dans la phase de la mise en place des voxels dans les listes effectuée par les threads, les structures de données destinées à chaque threads et contenant
une partie des voxels des listes peuvent être livrées à des threads une nouvelle fois ; les
threads vont effectués l’étape de propagation de la lumière pour propager la lumière
dans ces listes. Cette phase consiste à propager la lumière entre les voxels d’une même
liste. Or les listes sont incomplètes car un regroupement n’a pas été fait. Malgré cela,
il est possible de maintenir un résultat correct. Une étape est rajoutée, elle consiste à
échanger la lumière entre le dernier voxel d’une liste (i, j) localisée sur un thread donné
et le premier voxel de la même liste (i, j) localisée sur le thread suivant. La Figure 4.8
montre la propagation effectuée par les threads dans les listes incomplètes. Quand chacun des threads fini la propagation dans les listes incomplètes, une étape supplémentaire
est rajoutée pour échanger la lumière entre les voxels “e” et “g”, “f” et “u”, “j” et “n”,
83
comme étant des voxels consécutifs d’une même liste.
240
230
220
Temps (minutes)
210
200
190
180
170
160
150
1
2
3
4
5
6
7
Nombre de threads
8
9
10
Fig. 4.9 – L’effet de la variation du nombre de threads sur le temps. Le temps minimum
est obtenu avec deux threads
1200
Sans threads
Deux threads
Temps (minutes)
1000
800
600
400
200
0
1000
2000
3000 4000 5000 6000
7000
8000
Fig. 4.10 – Temps en fonction du nombre de directions scène d’une cabine
4.2.2.3
Résultats
Les tests sur l’utilisation des threads pour la distribution et la propagation de la
lumière dans les listes sont testés sur un noeud bi-processeur du cluster Laic. Un premier
test permettant de tester l’effet de la variation du nombre de threads sur le temps a été
effectué. Le temps obtenu sur une scène d’un salon fixant le nombre de directions à
2000, le nombre d’itérations à 6 et en variant le nombre des threads est montré en
1400
84
Sans threads
Deux threads
1200
Temps (minutes)
1000
800
600
400
200
0
1000
2000
3000
4000
5000
6000
7000
8000
Fig. 4.11 – Temps en fonction du nombre de directions scène de l’église
1200
Sans threads
Deux threads
Temps (minutes)
1000
800
600
400
200
0
1000
2000
3000 4000 5000 6000
7000
8000
Fig. 4.12 – Temps en fonction du nombre de directions scène de la salle de travail
Figure 4.9. Le temps minimum est atteint avec deux threads ; cela est normal car on
travaille avec des noeuds bi-processeurs, les deux threads peuvent donc se répartir sur
les deux bi-processeurs. En plus quand le nombre de threads augmente, plus d’échanges
sont nécessaires entre les structures de données des threads pour échanger la lumière
entre les voxels d’une même liste mais localisés sur différents threads, ce qui augmente
encore le temps. Un autre test consistant à fixer le nombre des threads à 2, le nombre
d’itérations à 6 et variant le facteur de direction est effectué. Ce test est effectué sur
trois différentes scènes, la scène d’une cabine, d’une église et d’une salle de travail. Les
Figures 4.10, 4.11 et 4.12 montrent les résultats obtenus. Un gain variant de 30 à 40
pourcent est obtenu grâce à l’utilisation des threads.
4.3
85
Distribution du calcul
Comme il a été noté au Chapitre 3, l’équation de radiosité (3.4) est linéaire par
rapport aux nombre de directions. Si D est l’ensemble de directions, et D1 , D2 , . . . , Dm
des sous-ensembles formant
une partition
deX
D, alors il est possible de diviser la somme
X X
X
en plusieurs somme
=
+
+... +
.
D
D1
D2
Dm
L’équation (3.4) peut s’écrire comme suit :
B(x) = Be (x) + ρd
X
B(V (x, ~σ )) cos θ(x, V (x, ~σ ))A(~σ )
~
σ ∈D
= Be (x) + ρd
X
B(V (x, ~σ )) cos θ(x, V (x, ~σ ))A(~σ )
~
σ ∈D1
+ρd
X
B(V (x, ~σ )) cos θ(x, V (x, ~σ ))A(~σ )
~
σ ∈D2
+
..
.
+ρd
X
B(V (x, ~σ )) cos θ(x, V (x, ~σ ))A(~σ )
~
σ ∈Dm
Fig. 4.13 – Distribution du calcul. Les données sont dupliquées sur chaque noeud. Chaque
noeud traite un ensemble de directions. Une phase de mise en commun des résultats est
nécessaire afin d’obtenir une solution finale d’illumination
86
Fig. 4.14 – Echange d’illumination entre les voxels dupliqués sur les noeuds
La distribution du calcul consiste alors à distribuer les directions entre les noeuds des
grappes. Chacun de ces noeuds traite un ensemble distinct de directions (Figure 4.13).
Les données sont dupliquées entre les noeuds et donc chacun des noeuds possède une
copie de tous les voxels de la scène : les données ne sont pas distribuées. Le principe
général de cette parallélisation revient alors à paralléliser la boucle intérieure de directions de l’algorithme d’illumination globale (TAB. 3.1). Il est important que la charge
du travail, c’est-à-dire l’ensemble de directions données à chaque noeud, soit égale pour
éviter les attentes entre les noeuds. Cette parallélisation offre deux avantages majeurs :
– Nécessite un minimum de communication entre les noeuds : les échanges entre les
noeuds sont effectués, grâce à la librairie MPI, à la fin de chaque itération quand
tous les noeuds auront finis le traitement d’illumination pour l’ensemble des directions qui leur a été assigné. Ces échanges consistent à mettre à jour l’illumination
des voxels en ajoutant l’illumination gagnée par chaque voxel dupliqué sur les
noeuds pour l’ensemble de directions (Figure 4.14) ;
– La possibilité d’utiliser les threads pour augmenter la parallélisation : la distribution des directions sur les noeuds bi-processeurs des grappes de stations de travail
n’empêche pas l’utilisation des threads qui peuvent être utilisés pour augmenter
aussi le grain de la parallélisation. Les threads sont utilisés (voir Section 4.2) pour
les deux calculs importants, la mise en place et la propagation de la lumière dans
les listes.
Notons finalement que la distribution des directions est très essentielles pour l’algorithme d’illumination car le facteur de directions augmente avec l’intensité des sources
lumineuses, il n’est pas borné comme le facteur d’itérations, et donc paralléliser ce facteur
permet une réduction importante du temps de calcul.
2000 directions
Temps Accélération
149
76
1,96
50
2,98
37
4,03
30
4,97
25
5,96
21
7,094
18
8,28
17
8,76
15
9,93
Nombre de noeuds
1
2
3
4
5
6
7
8
9
10
87
4597 directions
Temps Accélération
340
173
1,96
114
2,98
86
3,95
69
4,93
57
5,96
49
6,94
43
7,91
38
8,95
35
9,71
TAB 4.1 – Distribution du calcul (scène du salon) : temps de calcul et accélération en
fonction du nombre de noeuds pour deux différents nombres de directions
Sans threads
Deux threads
140
Temps (minutes)
120
100
80
60
40
20
0
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
Fig. 4.15 – Distribution du calcul effectuée sur la scène d’un salon utilisant 2000 directions et 6 itérations
4.4
88
Résultats de la parallélisation
La distribution du calcul a été testée sur le cluster Laic. Les tests sans l’utilisation des
threads et utilisant deux threads sont effectués sur une scène d’un salon composé d’un
million sept mille voxels. Les tests consistent à varier le nombre de noeuds, fixer le nombre
d’itértions à 6 et mesurer le temps de calcul. La Figure 4.15 et la Figure 4.16 montrent les
résultats de ces tests obtenus en utilisant 2000 et 4597 directions respectivement. Cette
parallélisation divise le temps de calcul par un facteur plus ou moins égal au nombre de
noeuds (tableau 4.1). Le temps de calcul est donc inversement proportionnel au nombre
de noeuds (Temps de calcul en parallèle × nombre de noeuds = temps séquentiel). L’efficacité de cette parallélisation atteint 98 pourcent. Le temps est réduit encore plus avec
l’utilisation des threads permettant un gain variant de 30 à 40 pourcent. Les threads
permettent de profiter de l’utilisation de la capacité entière du noeud. Cette approche
a montré une bonne accélération en temps de calcul ; sa seule limitation est qu’elle ne
distribue pas la mémoire : si l’on souhaite traiter des scènes qui n’entrent pas en mémoire
RAM de l’ordinateur, on ne pourra pas utiliser cette approche.
350
Sans threads
Deux threads
300
Temps (minutes)
250
200
150
100
50
0
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
Fig. 4.16 – Distribution du calcul effectuée sur la scène d’un salon utilisant 4597 directions et 6 itérations
4.5
Conclusion
Dans ce chapitre, nous avons étudié deux parallélisations : la parallélisation locale
et la distribution du calcul. La première parallélisation sert à augmenter le grain du
89
parallélisme traitant des tâches locales en parallèle en utilisant des threads et se servant
ainsi de toute la capacité des bi-processeurs. La deuxième parallélisation est très efficace
montrant un gain élevé divisant le temps de calcul par le nombre de noeuds. Ces deux
parallélisations sont donc performantes. La seule limitation provient de la mémoire. Les
données ne sont pas distribuées mais sont dupliquées sur les noeuds, ce qui restreint
l’utilisation de ces deux approches pour des scènes qui entrent en mémoire RAM d’un
noeud. Pour de petites scènes il n’y a aucun problème. Le problème se pose quand les
données augmentent en taille. La distribution des données répartit les données entre les
noeuds minimisant ainsi la mémoire requise pour chacun des noeuds. L’implémentation
est plus complexe à cause de la dépendance entre les voxels de la scène dans l’algorithme
d’illumination, nécessitant des échanges réguliers entre les noeuds. La distribution des
données constitue le but majeur de cette thèse et sera détaillée dans les chapitres à venir.
90
Chapitre 5
Distribution des données par
répartition des listes
La distribution du calcul de la méthode d’illumination globale (Chapitre 4) a
accéléré énormément l’algorithme séquentiel montrant un temps divisé par le nombre de
noeuds. Cependant, cette distribution reste restreinte à des scènes qui entrent en mémoire
centrale de chacun des noeuds du cluster car les données sont dupliquées sur les noeuds.
La méthode d’illumination globale que l’on cherche à paralléliser au cours de cette thèse
[CM06] discrétise les surfaces en voxels. Les voxels ont une taille uniforme et portent des
informations sur la propriété des surfaces (normale, émittance, coefficient de réflexion...).
Pour de grandes scènes contenant des millions de voxels, les données risquent de ne plus
tenir en mémoire, nécessitant ainsi un recours à la distribution des données. Dans ce
chapitre, une distribution des données par répartition des listes est proposée. Elle est
obtenue en distribuant des listes de voxels entre les noeuds d’un cluster. La méthode de
calcul d’illumination globale partitionne l’espace en listes de voxels où les voisins dans
une liste sont des voisins en terme de visibilité (Chapitre 3). La distribution des listes
de voxels entre les noeuds répartit les voxels et donc les données. Une telle distribution
facilite la propagation de la lumière car les listes de visibilité présentes sur chacun des
noeuds sont des listes complètes. Mais les listes de visibilité changent à chaque direction
nécessitant ainsi des échanges réguliers de voxels entre les noeuds.
Dans ce chapitre, une étude détaillée de la distribution des données par répartition
des listes est présentée. La manière d’organiser et de gérer les échanges représente la
partie délicate de cette parallélisation et sera alors traitée soigneusement. Les résultats
de cette parallélisation sont obtenus pour trois scènes différentes et sont présentés en fin
de chapitre.
5.1
Description générale de la méthode
La distribution des données par répartition des listes distribue des listes de voxels.
La distribution des listes des voxels n’a pas la même implication que la distribution
91
Chapitre 5. Distribution des données
92
des voxels. Elle garantit la présence des listes complètes de voxels sur un même noeud,
c’est-à-dire l’ensemble de tous les voxels appartenant à une même liste. La présence
des listes complètes sur un noeud offre un avantage pour la propagation de la lumière
dans les listes sur un noeud donné : cet avantage est la capacité du noeud à propager
la lumière dans ses propres listes sans être obligé d’échanger la valeur d’illumination
avec les voxels d’un autre noeud car aucun voxel appartenant à une même liste ne peut
se retrouver sur un autre noeud. Comme il a été noté dans le chapitre 3, les listes sont
caractérisées par un couple d’entiers (i, j) représentant la partition de l’espace en droites
discrètes. La distribution des listes entre les noeuds est accomplie en donnant à chaque
noeud un couple différent ou un intervalle des i et des j. Or quand la direction change
les (i, j) des voxels changent : un voxel qui a un certain (i, j) et qui appartient à la
liste L(i,j) pour une direction donnée, peut subir un changement de son ancien (i, j)
qui devient (i0 , j 0 ), et appartiendra alors à une autre liste L(i0 ,j 0 ) . Paralléliser les listes
demande alors une transition des voxels entre les noeuds afin de construire des listes
complètes sur chacun des noeuds, permettant de réaliser la propagation de la lumière
entre les voxels. La Figure 5.1 illustre le principe de cette parallélisation. Chacun des
trois noeuds est responsable du traitement d’un intervalle des i et j. Avec le changement
de direction les i et j des voxels changent, les listes présentes sur chacun des noeuds
ne sont pas nécessairement complètes : par exemple la liste (6, 7) est présente sur trois
noeuds différents nécessitant des échanges de voxels pour reconstruire une liste complète.
Fig. 5.1 – La distribution des listes sur 3 noeuds différents. Le changement de direction
(lignes pointillées) fait changer les listes à laquelles les voxels appartiennent et génère
des listes incomplètes de voxels
5.2
5.2.1
93
Tri des directions
Ordre lexicographique
L’algorithme séquentiel de calcul d’illumination globale [CM06] comprend une phase
de pré-calcul qui représente les 4 tris des voxels selon les 4 ordres lexicographiques
effectué une seule fois pour toute, tout en mémorisant les 4 tris de voxels. Cette phase
est de complexité 4 × O(N logN ) où N représente le nombre de voxels de la scène.
Lors du parcours de l’ensemble de directions, l’ordre lexicographique change en passant
d’une direction à une autre si l’orientation de celle-ci change. À chaque changement de
direction, au lieu de re-trier les voxels à chaque fois, il est possible de choisir parmi
les quatre tris de voxels, le tri convenable. Malheureusement, ce pré-calcul ne reste pas
valable pour la parallélisation des listes.
Lors de la parallélisation des listes, les listes sont distribuées entre les noeuds et à
chaque direction, les voxels sont échangés entre les noeuds. Cela rend impossible le précalcul de 4 tris de voxels en ordre lexicographiques car les voxels appartenant à un noeud
donné ne sont pas toujours les même à cause de la transition des voxels entre les noeuds.
Il est alors nécessaire à chaque direction de re-trier les voxels. Faire le tri à chaque
direction surtout si les directions exigent un changement de l’ordre lexicographique à
chaque fois, bouleverse tout l’ordre de voxels. Cela rend le tri coûteux et risque une
augmentation du temps de calcul d’illumination alors que le but est d’essayer de baisser
la complexité temporelle autant que possible.
Pour résoudre ce problème, la solution est proposée ; pourquoi ne pas trier les directions de manière à engendrer le moins de changement d’ordre lexicographique. Un tri
de directions consiste à trier les directions selon leur vecteur directeur (a, b, c). 8 possibilités existent selon le signe du vecteur directeur ((a > 0, b > 0, c > 0), (a > 0, b >
0, c < 0), (a > 0, b < 0, c > 0), (a > 0, b < 0, c < 0), (a < 0, b < 0, c < 0), (a < 0, b <
0, c > 0), (a < 0, b > 0, c < 0), (a < 0, b > 0, c > 0)) et chacune de ces 8 possibilités
correspond à un ensemble de directions ayant un vecteur directeur satisfaisant le signe
d’un de ces 8 cas et générant un ordre lexicographique particulier. Cela maintient l’ordre
lexicographique stable pour plusieurs directions et génère huit changement d’ordre lexicographique durant une itération, ces ordres sont les suivants : ((x ↑, y ↑, z ↑), (x ↑, y ↑, z ↓
), (x ↑, y ↓, z ↑), (x ↑, y ↓, z ↓), (x ↓, y ↓, z ↓), (x ↓, y ↓, z ↑), (x ↓, y ↑, z ↓), (x ↓, y ↑, z ↑)).
Il faut noter finalement que le tri des directions minimise au plus le nombre de
changement de l’ordre lexicographique et le maintient stable pour un grand ensemble de
directions. Un autre problème se pose. Il s’agit de maintenir les voxels en provenance
des autre noeuds dans leur ordre lexicographique avec les voxels déjà présents sur le
noeud. En effet, les voxels déjà présents sur un noeud donné sont triés dans l’ordre
lexicographique. Or les voxels qui transitent et qui sont en provenance des autres noeuds
doivent être rajoutés à leur bon emplacement dans l’ordre lexicographique parmi les
voxels existants sur le noeud (voir Section 5.5).
5.2.2
94
Directions voisines
La distribution des listes demande des échanges de voxels entre les noeuds. Minimiser
ces échanges est souhaitable afin de minimiser le temps perdu pour l’envoi et le rassemblement des données entre les noeuds. Le couple (i, j) qui dénote la liste à laquelle un
voxel appartient peut être calculé à partir de l’équation (5.1). Cette équation est dépendante des coordonnées (x, y, z) du voxel et du vecteur directeur (a, b, c) de la direction
à traiter.
Etant donné un voxel v de coordonnées (x, y, z) et une direction D, le couple (i, j)
est calculé à partir de l’équation (5.1). En changeant la direction D vers une direction
voisine D0 , l’équation (5.1) mène à une nouvelle liste (i0 , j 0 ) qui est très proche de (i, j), à
laquelle le voxel v appartient. Des directions voisines engendre alors une petite variation
de la valeur de (i, j).
Fig. 5.2 – La distribution des listes entre
les noeuds consiste à donner à chacun
des noeuds un intervalle (i, j) spécifique
à traiter
Fig. 5.3 – Le nombre de voxels qui sort
à l’extérieur d’un noeud sera minimisé
(partie hachurée) en prenant deux directions voisines
La parallélisation des listes distribue des listes de voxels entre les noeuds en spécifiant
pour chacun des noeuds un intervalle (i, j) spécifique à traiter (Figure 5.2). L’intervalle
est choisit de manière à établir un équilibrage de charge entre les noeuds sera détaillé en
Section 5.3. Le tri des directions de l’espace pour qu’elles soient voisines, provoque une
petite variation de (i, j) ce qui implique que la plupart des voxels reste sur un noeud
donné et seule une petite partie transite vers un autre noeud (Figure 5.3). Le tri des
directions les rendant voisines est achevé à travers un parcours particulier de la sphère
discrète illustré dans la Figure 5.4.
i × ωab ≤ −bx + ay < (i + 1) × ωab
j × ωac ≤ −cx + az < (j + 1) × ωac
(5.1)
95
htb
Fig. 5.4 – Parcours de la sphère pour obtenir des directions voisines
5.2.3
Tri final
Comme il a été noté dans les Sections 5.2.1 et 5.2.2, deux tris des directions sont
nécessaires. Le premier est le tri des directions selon le vecteur directeur de la direction.
Cela permet de garder un ordre lexicographique stable générant seulement 8 changements d’ordre lexicographique. Le deuxième est le tri des directions en directions voisines minimisant ainsi les échanges de données entre les noeuds du cluster. Ces deux tris
peuvent être satisfaits en traversant chaque 1/8 de la sphère discrète suivant le parcours
montré en Figure 5.4. Le choix du 1/8 de la sphère garantie la maintenance d’un même
ordre lexicographique pour toutes les directions et le parcours à l’intérieur d’un même
quadrant garantit la génération de directions voisines.
5.3
Distribution statique et dynamique des listes
La distribution des listes de voxels entre les noeuds se fait en désignant à chacun des
noeuds un intervalle bornée de (i, j) correspondant aux listes Lij dont il sera responsable.
Cette distribution nécessite des échanges de voxels entre les noeuds à chaque direction
afin de construire des listes complètes de voxels contenant tous les voxels de la scène
appartenant à une même liste. A travers un tri convenable de voxels, il est possible en
passant d’une direction à une autre d’avoir un minimum de voxels qui transitent d’un
noeud à un autre. Malgré la minimisation des échanges, il y a toujours des voxels qui
transitent entre les noeuds, ce qui fait qu’au bout d’un certains nombre de directions, un
déséquilibre est remarqué nécessitant un équilibrage de charge entre les noeuds. Il existe
deux manières de réaliser la distribution des listes en respectant l’équilibrage de charge :
la première est une distribution statique et la deuxième une distribution dynamique et
ces deux distributions sont détaillées ci-dessous.
5.3.1
96
Distribution statique des listes
La première idée pour distribuer les listes entre les noeuds consiste à calculer pour
tous les voxels de la scène et pour toutes les directions, les plus grandes valeurs des i et
j qui peuvent être atteintes. Une fois ces valeurs calculées, une distribution statique des
i, j dépendant du nombre de noeuds est effectuée (voir Figure 5.5) de sorte que chacun
des noeuds aura à traiter une longueur d’intervalle des i et j plus ou moins égale.
Fig. 5.5 – Distribution statique et déséquilibre du nombre de voxels entre les noeuds
Or cet équilibrage statique a beaucoup d’inconvénients. Etant donné une scène en 3D,
les (i, j) des voxels pour une direction donnée sont largement liés à l’architecture de la
scène. Cela fait que cette distribution statique, quand on traite de milliers des directions,
peut mener à un déséquilibre entre les noeuds, où certains noeuds ont beaucoup moins
de voxels que d’autres. Ce déséquilibre obligera les noeuds qui ont moins de voxels à
attendre ceux qui ont plus de voxels. Ceci est un inconvénient pour la parallélisation
et provoque une augmentation du temps de calcul et une désynchronisation entre les
noeuds (Figure 5.5). L’inefficacité de la distribution statique des listes, pousse à trouver
un autre moyen pour la répartition des listes entres les noeuds pouvant maintenir un
équilibrage de charge entre les noeuds ; cette distribution est la distribution dynamique
des listes que nous abordons maintenant.
97
Fig. 5.6 – Distribution dynamique des listes : (a) Calcul du nombre de voxels des listes
sur chacun des noeuds. (b) La distribution globale des listes parmi tous les noeuds (c)
Algorithme élastique d’équilibrage de charge : la meilleur distribution lignes permettant
de distribuer l’intervalle des i de l’algorithme élastique. (d) La meilleur distribution colonnes permettant de distribuer les j pour aboutir à une distribution finale des intervalles
des (i, j) parmi les noeuds
5.3.2
98
Distribution dynamique des listes
La distribution statique des listes apparaît non raisonnable car elle ne maîtrise pas le
nombre de voxels entre les noeuds et peut causer des déséquilibres importants. Malgré
la petite quantité de voxels qui transitent entre les noeuds, la répartition des voxels
évolue avec la direction, il est alors intéressant de trouver pour une direction donnée
la bonne distribution des listes qui permettra d’établir l’équilibre de voxels entre les
noeuds en donnant à chacun, un intervalle (i1 ...in ) et (j1 ...jn ) de listes à traiter. La
meilleure manière d’établir un équilibre de voxels entre les noeuds est d’adopter une
distribution dynamique de voxels qui peut changer avec la direction afin de maintenir
tout au long du calcul de l’illumination, un équilibre de charge entre les noeuds. Il faut
noter que le problème d’équilibrage de charge est NP-complet en 2D, c’est pour cela
qu’on effectue une équilibrage de charge en 1D. L’algorithme d’équilibrage de charge
adopté pour équilibrer les charges entre les noeuds est basé sur l’algorithme élastique
expliqué dans [MP97, MR92, Mig92], et duquel un algorithme plus général d’équilibrage
de charge par redistribution des données est dérivé [Fes98, FMP98].
Les étapes effectuées par chacun des noeuds du cluster afin d’équilibrer les charges
et d’arriver à une bonne distribution des listes entre les noeuds sont les suivantes :
• Compter le nombre de voxels appartenant à chacune des listes. Les listes ne sont
pas encore construites, la reconstruction se fait après l’envoi et la réception des
voxels. Malgré cela, il est possible de compter le nombre de voxels que chaque liste
va contenir en calculant le (i, j) de chaque voxel et en rajoutant 1 au compteur
d’une liste donnée à chaque fois qu’un voxel appartenant à cette liste est rencontré.
Chaque noeud construit alors une matrice contenant le nombre de voxels pour
chacune de ses listes (Figure 5.6 (a))
• Effectuer des échanges collectifs entre les noeuds pour échanger le nombre de voxels
que chaque liste contient en additionnant les voxels d’une même liste présente sur
différent noeuds. Cela permet d’obtenir une matrice représentant une distribution
globale des (i, j) de la scène (Figure 5.6 (b)).
• Trouver à partir de la matrice de distribution globale, la meilleur distribution
des (i, j) entre les noeuds qui permet d’établir un équilibrage de charge entre les
noeuds affectant à chacun des noeuds environ le même nombre de voxels. L’algorithme élastique est utilisé pour trouver cette distribution [MP97, MR92, Mig92].
L’application de cet algorithme en 2-D est effectué comme suit :
– Trouver le nombre de divisions ligne et celui des divisions colonnes. Ces nombres
dépendent du nombre de noeuds. Le nombre de divisions lignes est donné par la
racine carrée du nombre de noeuds arrondie à la partie entière la plus proche.
Le nombre de divisions colonnes pour chacune des divisions lignes est calculé en
divisant le nombre de noeuds par le nombre de divisions lignes et s’il y en a un
reste, il est réparti sur chacune des divisions colonnes jusqu’à ce qu’il soit nul.
Par exemple dans le cas de 13 noeuds, 4 divisions lignes sont nécessaires, quant
à la divisions colonnes, la première ligne est répartie en 4 colonnes et les autres
lignes sont réparties en 3 colonnes chacune (Figure 5.7) ;
99
– Calculer la somme de chacune des lignes ; diviser la somme totale des voxels
de la scène par le nombre de lignes, et trouver la distribution des lignes correspondantes. Par exemple avec 3 noeuds, 2 divisions lignes sont nécessaires ; la
première division ligne doit contenir deux fois plus de voxels que la deuxième
division ligne car elle est distribuée en 2 colonnes alors que la deuxième n’est
pas répartie, elle contient une colonne unique (Figure 5.6 (c)) ;
Fig. 5.7 – Divisions par lignes et colonnes dépendant du nombre de noeuds
– Effectuer la distribution par colonne. La distribution par colonne est effectuée
en additionnant chacune des colonnes pour les lignes concernées. La meilleure
division colonne, qui cède le même nombre de voxels à chaque partie, est ensuite
calculée (Figure 5.6 (d)) ;
– Déduire la distribution final des (i, j). L’exemple en Figure 5.6 (d) montre les
intervalles (i,j) permettant d’aboutir à un équilibrage de charge entre les noeuds
et délivrer à chacun des noeuds plus ou moins un nombre de voxels equitable.
Pour cet exemple, le N oeud 1 traite les i = (0...3) et j = (0...3), le N oeud 2
traite les i = (0...3) et j = (4...6) et N oeud 3 traite les i = (4, 5) et j = (0...6).
L’idée de listes de visibilité de l’algorithme d’illumination fait que les listes de voxels
changent en changeant de direction. La transition des voxels entre les noeuds se fait alors
à chaque changement de direction. Il est vrai que le nombre de voxels qui transitent
est limité, pourtant il est désirable d’effectuer un équilibrage à chaque changement de
direction afin de maintenir un équilibre parfait entre les noeuds. L’équilibrage de charge
dynamique adopté n’est pas coûteux s’il est effectué un nombre de fois limité, or s’il
doit être effectué à chaque direction, le temps de calcul devient énorme. La complexité
temporelle vient du fait que, compter le nombre de voxels pour toutes les listes présentes
sur un noeud est coûteux, ensuite le transfert de ces nombres entre les noeuds pour
faire la somme entre les listes ayant un même (i, j) parmi tous les noeuds est encore
coûteux. Dans l’algorithme d’illumination globale, les mêmes directions se répètent à
chaque itération. Il est possible alors d’effectuer l’équilibrage pour toutes les directions
de la première itération, mémoriser chaque distribution (i, j) trouvée en mémoire, et
ensuite pour les directions des autres itérations, charger la distribution correspondante
directement de la mémoire. La mémorisation de ces distributions n’est pas coûteuses :
elle revient à maintenir (N ombre de noeuds)3/2 entiers à chaque direction. Il est possible
100
aussi de se poser la question pourquoi ne pas faire un équilibrage de charge de temps en
temps quand un déséquilibre remarquable est remarqué ? La Figure 5.8 montre l’effet de
variation de la fréquence d’effectuer l’équilibrage de charge sur le temps de calcul sans et
avec l’utilisation des threads. L’équilibrage de charge est fait de temps en temps quand
un déséquilibre d’un pourcentage donné (axe des x) entre les noeuds est remarqué. Il
est clair que le temps diminue au début jusqu’à la valeur 30 ; après cette valeur, quand
l’équilibrage est effectué plus souvent le temps de traitement augmente. Le meilleur
temps de calcul est obtenu pour la valeur 100, quand l’équilibrage est effectué à chaque
direction indiquant une synchronisation complète entre les noeuds. La Figure 5.9 montre
un test effectué pour tester l’équilibrage de charge sur la scène de la salle de travail
composée de 3.25 millions de voxels en prenant une direction aléatoire. Il est clair que
le nombre de voxels présents sur les noeuds est équilibré en allant de 2 à 10 noeuds.
800
Sans threads
Deux threads
Temps (minutes)
700
600
500
400
300
200
100
0
10
20
30
40
50
60
70
80
90 100
Pourcentage de déséquilibre
Fig. 5.8 – L’effet d’augmention de la fréquence d’équilibrage de charge sur le temps
5.4
Remplissage et échange des données
Après avoir trouvé les intervalles i et j permettant d’établir un équilibrage de charge à
travers une bonne distribution des listes, pour un noeud donné, les voxels n’appartenant
pas à l’intervalle des i et j désigné au noeud, doivent être remplis pour être envoyés au
noeud destinataire. Donc à chaque changement de direction, chaque noeud doit parcourir
ses voxels rangés dans l’ordre lexicographique, et décider selon le (i, j) de chacun, s’il doit
rester sur le noeud ou s’il doit quitter vers un autre noeud. Les voxels qui doivent quitter
le noeud sont mis à leur emplacement dans la structure d’envoi. La structure d’envoi
est une matrice de dimension 1, libellée par rapport au noeud destinataire, où chaque
case contient tous les voxels destinés à un noeud donné. Le parcours des voxels dans leur
Nombre de voxels
101
1.65e+006
1.55e+006
1.45e+006
1.35e+006
1.25e+006
1.15e+006
1.05e+006
950000
850000
750000
650000
550000
450000
350000
2 noeuds
3 noeuds
4 noeuds
5 noeuds
6 noeuds
7 noeuds
8 noeuds
9 noeuds
10 noeuds
1
2
3
4
5
6
7
8
Identité (rank) du noeud
9
10
Fig. 5.9 – Le nombre de voxels est equilibré sur les noeuds en allant de 2 à 10 noeuds
ordre lexicographique assure que tous les voxels rangés pour être envoyés à un même
noeud destinataire (voxels appartenant à chaque case de la matrice) sont aussi rangés
sans l’ordre lexicographique, évitant ainsi le tri de ces voxels dans l’ordre lexicographique
à la réception. Or pour le fusion des données reçues avec ceux existant sur un noeuds,
un certains tri est nécessaire, dont plus de détails sont donnés en Section 5.5. Une fois le
remplissage des données effectué, les échanges des ensembles de voxels, entre les noeuds,
sont effectués. Ces échanges comprennent l’envoi des voxels aux autres noeuds et la
réception des voxels des autres noeuds. Les données à envoyer sont envoyées dans leur
ordre lexicographique au noeud destinataire. Les voxels reçus sont encore libellés par
rapport au noeud duquel ils proviennent.
Il faut noter que lors des échanges des voxels, toute les informations du voxel sont
transmises. Chaque voxel contient plusieurs informations. Les infomations d’un voxel
sont les coordonnées (x, y, z) (trois entier), la normale (3 float), la couleur en RGB (trois
float), la radiosité cumulée en RGB (3 float), l’émittance (1 float), le coefficient de radiosité (1 float) et le cosinus de l’angle (1 float). La Figure 5.10 montre un exemple
du remplissage des voxels. Au début les voxels de la scène sont rangés dans leur ordre
lexicographique, pour une direction Direction1, les voxels (initialement pas encore distribués entre les noeuds) sont distribués entre les noeuds de sorte à établir des listes
complètes sur chacun des noeuds (noeud 1 par exemple traite les listes dont i = 1...5
et j = 1...2) permettant la propagation de la lumière dans les listes. Quand la direction
change, Direction2, la distribution des listes n’est pas la même (noeud 1 par exemple
traite les listes dont i = 1...3 et j = 1...3) et donc les voxels qui ne conviennent pas à
la distribution recherchée doivent être envoyés au noeud impliqué. Les voxels sont rangés dans des structures d’envoi libellées par rapport au noeud destinataire et les envois
réceptions sont achevés entre les noeuds.
102
Fig. 5.10 – Distribution des données par répartition des listes entre les noeuds : (a)
Une première distribution des voxels de la scène par distribution des listes. (b) Pour un
changement de direction, la distribution des listes change et les voxels à échanger sont
rangés dans des structures d’envoi libellées par rapport au noeud destinataire. (c) Fusion
des voxels reçus des autres noeuds avec les voxels présents sur le noeud
5.5
103
Fusion des données
Les donnés reçues par chacun des noeuds sont libellées par rapport au noeud d’envoi. Pour un noeud donné, l’ensemble des voxels qui y sont présents sont rangés dans
l’ordre lexicographique : chacun des ensembles de voxels en provenance des autres noeuds
vers le noeud courant sont aussi rangés en ordre lexicographiques. A partir de tous ces
ensembles, il faut arriver à construire un seul ensemble de voxels rangés en ordre lexicographique. Cela est possible grâce à l’algorithme de la recherche dichotomique [Sed01]
qui va permettre de fusionner chacun des ensembles triés avec les voxels déjà existant
sur le noeud. Une fois cette étape effectuée, la distribution des voxels dans leurs listes
et la propagation dans ces listes sont effectuées ; les listes sont des listes complètes de
voxels contenant tous les voxels d’une même liste. La recherche dichotomique dans une
tableau de taille N nécessite au plus O(log2 (N )) comparaisons, elle est alors coûteuse
pour un grand nombre de voxels. Or pour l’algorithme d’illumination que l’on cherche
à paralléliser, les voxels échangés entre les noeuds sont, la plupart du temps, limités en
nombre (les directions sont voisines, le couple (i, j) varie lentement), ce qui fait que la
fusion des données n’est pas très coûteuse. La Figure 5.10 montre un exemple de fusion
des données présentes sur chacun des noeuds avec les données reçues des autres noeuds
afin de construire un vecteur de voxels final contenant tous les voxels présents sur le
noeuds rangés dans l’ordre lexicographique. Ces voxels sont ensuite mise en place dans
leurs listes pour y propager la lumière.
5.6
Étapes de l’algorithme d’illumination par répartition des listes
Après avoir expliqué la parallélisation des données par répartition des listes ainsi
que les parties essentielles de cette parallélisation, il est important de noter les étapes
de cette parallélisation enchaînées en ordre. Ces étapes sont effectuées par chacun des
noeuds et peuvent se résumer comme suit :
– Générer les directions voisines et les trier en fonction du signe de leur vecteur
directeur en suivant le parcours de chaque 1/8 de la sphère discrète (Figure 5.4)
Pour chaque itération et pour chaque direction, faire :
– Trier les voxels si nécessaire. L’ordre lexicographique reste le même pour un ensemble de directions et 8 changements de cet ordre sont rencontrés pour toutes les
directions ;
– Si c’est le cas de la première itération, trouver la bonne distribution des listes entre
les noeuds en suivant toutes les étapes marquées en Section 5.3.2 et mémoriser
cette distribution en mémoire. Si on n’est pas à la première itération, la bonne
distribution des listes est obtenue directement en effectuant son chargement de la
mémoire ;
– Remplir les voxels à envoyer ;
104
– Envoyer les voxels parmi les noeuds ;
– Recevoir les voxels en provenance des noeuds ;
– Fusionner les voxels reçus avec ceux présents sur un noeud, en respectant l’ordre
lexicographique ;
– Mettre les voxels dans leurs listes et propager la lumière entre les voxels d’une
même liste ;
– Remise à zéro des listes.
5.7
Parallélisation locale et distribution des données
Comme il a été noté en section 4.2, les deux étapes essentielles de calcul d’illumination
globale (la mise en place des voxels dans leurs listes de visibilité et la propagation de
la lumière dans ces listes) peuvent être parallélisées localement en distribuant les voxels
sur différents threads.
Scène d’une église
Scène d’une cabine
500
1000
4597 directions
6271 directions
800
Temps (minutes)
Temps (minutes)
400
300
200
600
400
200
100
0
0
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
Fig. 5.11 – Temps en fonction du
nombre de noeuds scène de la cabine
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
nombre de noeuds scène de l’église
La distribution des données par répartition des listes place les voxels de manière
à avoir des listes complètes de voxels sur chacun des noeuds. Les échanges de voxels
se font selon le (i, j) (partitionnement de l’espace en droites) de chacun des voxels.
C’est juste après la transition des voxels entre les noeuds et la fusion de ceux-ci en
ordre lexicographique que la dernière étape qui consiste à mettre en place et propager
la lumière dans les listes de visibilité est achevée. Cette dernière étape est la même
qu’en séquentiel et elle peut donc être parallélisée localement sur chacun des noeuds
en distribuant les voxels sur les threads (voir Section 4.2). Cette parallélisation locale
permet de profiter de toutes les capacités des noeuds du cluster sur lequel la distribution
de données est menée. Les résultats et les tests effectués sur la parallélisation locale et
la distribution des données par répartition des listes sont montrés dans la section 5.8.
5.8
105
Résultats et discussion
Les résultats de la distribution des données par répartition des listes ont été testés
sur le cluster Laic. Trois scènes sont utilisées pour les tests, la scène de la cabine, de
l’église et de la salle de travail. Les premiers tests consistent à utiliser 6 itérations et
différents nombre de directions pour les trois scènes. Une nombre de directions égale à
4597 est testé pour les trois scènes, 6271 directions pour la scène de l’église et 8209 pour
la scène de la salle de travail. Les temps de calcul pour chacune des trois scènes sont
montrés respectivement dans les Figures 5.11, 5.12 et 5.13. Il est possible de remarquer
que le temps de calcul diminue quand le nombre de noeuds augmente.
Scène d’une salle de travail
4597 directions
8209 directions
Temps (minutes)
1000
800
600
400
200
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 5.13 – Temps en fonction du nombre de noeuds scène de la salle de travail
Une description détaillée du temps de chaque opération de la parallélisation est montré en Figure 5.14 et 5.15. Ces 2 figures représentent respectivement la scène de l’église
avec 6207 directions et la scène de la salle de travail avec 4597 directions. En effet, l’algorithme séquentiel comprend deux temps de calcul qui sont importants, la mise en place
de voxels et la propagation de lumière dans les listes. Lors de la distribution des données
par répartition des listes, les mêmes opérations présentes en séquentiel se répètent et
ces opérations sont divisées par le nombre de noeuds. En plus d’autres opérations se rajoutent. Ces opérations sont le temps du remplissage de voxels à envoyer, d’équilibrage
de charge, d’échanges des données et de fusion des données. Une discussion des temps
révélés par ces figures peut se résumer comme suit :
– Remplissage de données : le remplissage de données est une opération coûteuse en
temps de calcul car un parcours de tous les voxels doit être effectué, et les voxels
à envoyer doivent être stockés dans la structure de données correspondante. On
peut constater dans les Figures 5.14 et 5.15 que cette opération est plus ou moins
divisée par le nombre de noeuds et donc diminue bien quand le nombre de noeuds
900
550
Fusion
Envoi et réception
Remplissage
Equilibrage
Mise en place et propagation
800
Fusion
Envoi et réception
Remplissage
Equilibrage
500
450
Temps (minutes)
700
Temps (minutes)
106
600
500
400
300
400
350
300
250
200
150
200
100
100
50
0
0
2
4
6
Nombre de noeuds
8
10
Fig. 5.14 – Distribution temporelle des
différentes opérations de la parallélisation en fonction du nombre de noeuds
(scène de l’église)
2
4
6
Nombre de noeuds
8
10
Fig. 5.15 – Distribution temporelle des
différentes opérations de la parallélisation en fonction du nombre de noeuds
(scène de la salle de travail)
augmente ;
– Equilibrage de charge : les Figures 5.14 et 5.15 montrent que le temps d’équilibrage
de charge ne varie pas trop en fonction de la variation du nombre de noeuds ; il
est presque stable en temps. Notons que cet équilibrage n’est effectué que pour les
directions de la première itération (voir section 5.3.2) ;
– Echange des données : le temps des échanges est négligeable par rapport au temps
des autres opérations ; cela est du au fait qu’un petit pourcentage de voxels est
échangé entre les noeuds à chaque direction ;
3
2.4
2.5
2.2
Accélération
Accélération
4597 directions
6271 directions
2
2
1.8
1.6
1.4
1.5
1.2
1
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 5.16 – Accélération en fonction du
nombre de noeuds pour trois différentes
scènes
2
3
4
5
6
7
8
9
10
Nombre de noeuds
nombre de noeuds pour la scène de
l’église
– Fusion des données : Le temps de fusion consiste à fusionner les voxels reçus avec
107
les voxels existants sur le noeud. Ce temps dépend de la quantité des données à
échanger entre les noeuds et ne varie pas énormément avec le nombre de noeuds.
4597 directions
8209 directions
2.6
2.4
Accélération
2.2
2
1.8
1.6
1.4
1.2
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 5.18 – Accélération en fonction du nombre de noeuds scène de la salle de travail
4
Scène d’une cabine (sans thread)
Scène d’une cabine (2 threads)
500
400
3
Accélération
Temps (minutes)
3.5
300
200
2.5
2
1.5
1
100
0.5
0
0
2
3
4
5
6
7
8
9
10
Nombre de noeuds
nombre de noeuds pour la scène de la
cabine avec et sans threads
2
3
4
5
6
7
8
9
10
Nombre de noeuds
nombre de noeuds pour la scène de la
cabine avec et sans threads
Du point de vue accélération, la Figure 5.16 montre l’accélération en fonction du
nombre de noeuds des trois scènes en prenant un même nombre de directions (4597)
pour les trois scènes et 6 itérations. Il est possible de remarquer qu’une accélération de
maximum 2.85 est remarquée avec 10 noeuds. Aussi les Figures 5.17 et 5.18 montrent
l’accélération en fonction du nombre de noeuds pour la scène de l’église et de la salle
de travail respectivement prenant en compte deux facteurs de directions pour chacune
des scènes. Une accélération de maximum ≈2.4 est remarquée avec 10 noeuds. On peut
dire en se basant sur ces tests que l’accélération offerte par cette parallélisation n’est pas
énorme. Cela est dû aux opérations rajoutées par la parallélisation ainsi qu’au temps
108
nécessaire pour gérer et échanger les données. Quand le nombre de voxels transitant
augmente, le temps de remplissage de ces voxels dans des structures d’envoi augmente,
le temps des envois et réceptions augmente, ainsi que le temps de fusion des données
reçues par un noeud avec les données déjà existantes augmente ce qui fait qu’au final, le
temps de toutes les opérations rajoutées par la parallélisation augmente.
La parallélisation locale utilisant les threads peut être rajoutée à la distribution des
données comme expliqué en Section 5.7. Cette parallélisation permet d’augmenter la parallélisation en profitant de toute la capacité des noeuds du cluster (chaque noeud est un
bi-processeur). Les Figures 5.19 et 5.20 montre respectivement le temps et l’accélération
en fonction du nombre de noeud pour la scène de la cabine utilisant 4597 directions et 6
itérations. Les threads font augmenter l’accélération à un facteur de 3.2 avec 10 noeuds.
5.9
Conclusion
La distribution des listes a permis la distribution des voxels et donc des données.
Cette parallélisation permet de traiter de grandes scènes qui n’entrent pas en mémoire
centrale d’un noeud. Une réduction du temps de calcul est obtenue en augmentant le
nombre de noeuds permettant d’arriver à une accélération d’un facteur de 3.2 avec 10
noeuds. Cette accélération ainsi que l’efficacité de cette parallélisation ne sont pas aussi
performantes que prévu initialement. Cela est dû aux différentes opérations rajoutées
par la parallélisation. Malgré le fait que la quantité de données transitante ne dépasse
pas 10% du nombre total de voxels présents sur un noeud, cette parallélisation demande
un temps pour gérer les différentes opérations imposées par l’enchaînement des tâches
de l’algorithme d’illumination.
On peut dire que cette parallélisation aurait pu être efficace si les voxels avaient été
stables sur les noeuds, c’est-à-dire si les listes étaient toujours complètes sur les noeuds ce
qui permettrait d’éviter plusieurs opérations. Malheureusement, ce n’est pas le cas. Il y
a toujours un pourcentage de voxels qui transitent entre les noeuds diminuant l’efficacité
de la parallélisation.
Pour toutes ces raisons, le chapitre suivant traite une deuxième parallélisation, la
distribution des données par division de la scène en des sous-parties indépendantes.
Cette approche réalise la transmission des données nécessaires entre les noeuds sans
avoir recours à une transmission des voxels entre les noeuds. Une fois distribués entre
les noeuds, les voxels restent stables.
Chapitre 6
Distribution des données par division
de la scène
La distribution des données par répartition des listes étudiées au Chapitre 5, a
permi de distribuer la mémoire et de minimiser le temps de calcul. Une autre approche
importante à tester est la distribution des données par division de la scène. Dans cette
approche la scène est distribuée, selon la densité des voxels, sur les différents noeuds
du cluster, assignant à chacun des noeuds une partie équitable des voxels. Les voxels
sont fixes sur les noeuds et ne transitent pas comme dans la distribution des listes. Les
échanges d’illumination sont effectués entre les voxels voisins en terme de visibilité et
localisés sur des noeuds distincts.
Deux approches sont prévues pour cette parallélisation et sont étudiées dans ce chapitre. La première consiste à établir une topologie cartésienne entre les noeuds. Chaque
noeud communique et échange les informations d’illumination avec les deux noeuds qui
sont voisins. La deuxième approche consiste à faire des communications collectives pour
les échanges de données entre les noeuds. Chaque noeud communique alors avec tous les
autres noeuds et non plus seulement avec ses voisins directs. Cette deuxième approche a
montré des meilleurs résultats par rapport à la première, communiquant les informations
d’illumination aux noeuds impliqués directement sans se restreindre aux noeuds voisins
pour la communication.
6.1
Principe
La distribution des données par division de la scène consiste à diviser la scène en plusieurs parties ou sous-environnement séparées par des barrières virtuelles. Les barrières
sont déposées de manière à respecter la densité équitable des voxels entre les noeuds
(Section 6.2). L’idée de cette distribution en sous-environnement ressemble à celle de
“l’interface virtuelle” utilisée dans [RAPP97].
La distribution des données par division de la scène se distingue de l’approche de
répartition des listes (Chapitre 5) par le fait que les voxels ne transitent pas mais sont
109
Chapitre 6. Distribution des données par division de la scène
110
stables sur les noeuds ce qui élimine tout risque de déséquilibre entre les noeuds. Les
échanges d’illumination sont effectués entre les voxels voisins en terme de visibilité mais
localisés sur des noeuds distincts.
Dans l’algorithme d’illumination à paralléliser [CM06], la propagation de la lumière
pour le calcul de l’illumination se fait entre les voxels voisins d’une même liste de visibilité. En divisant la scène en parties, pour chaque direction, les listes de visibilité sont
construites sur chacun des noeuds. Des voxels appartenant à une même liste peuvent
être localisés sur différents noeuds. Cela exige des échanges de la valeur d’illumination
des voxels concernés entre les noeuds.
Normalement les échanges concernent l’illumination du premier et le dernier voxel
d’une liste donnée qui sera communiquée à son voisin en terme de visibilité dans la liste
de visibilité localisée sur les noeuds précédents ou suivants (Figure 6.1). Deux différentes
approches sont utilisées pour appliquer cette distribution : la première consiste à utiliser
une topologie cartésienne et des communications non bloquantes et la deuxième utilise
des communications collectives pour les échanges entre les noeuds. Les détails de ces
deux approches ainsi que les résultats fournis sont décrits en Section 6.3 et Section 6.4.
Fig. 6.1 – Echanges d’illumination entre les noeuds. Les échanges concernent le premier
et le dernier voxel de chaque liste et leurs voisins en terme de visibilité localisés sur les
noeuds précédents ou suivants
6.2
Division de la scène
La division de la scène est une division en dimension 1. L’image 3D est divisée selon
la dimension la plus grande (longueur, largeur ou hauteur). La division prend en considération la densité des voxels ainsi que le nombre de divisions. Le nombre de divisions
dépend du nombre de noeuds du cluster sur lequel la parallélisation va s’effectuer. Le
but est d’arriver à donner à chaque partie et par la suite à chaque noeud du cluster,
111
le même nombre de voxels (Figure 6.2). L’algorithme utilisé pour rechercher la meilleur
division de la scène est similaire à celui vu en Section 5.3.2, basé sur l’algorithme élastique. Cependant au lieu de faire une distribution par ligne puis une distribution par
colonne, une seule distribution en une dimension est réalisée. Cette distribution se fait
suivant l’un des trois axes, x, y, ou z.
Fig. 6.2 – Distribution de la scène selon la densité
Fig. 6.3 – Une topologie cartésienne à une dimension entre les noeuds
6.3
6.3.1
Approche par topologie cartésienne et communications non bloquantes
Principe
MPI permet de construire une topologie virtuelle entre les noeuds. La topologie virtuelle est un mécanisme qui consiste à nommer les noeuds en lien avec la procédure
de communication. Elle facilite le codage au programmeur pour les envois et réceptions des messages et aussi optimise les communications entre les noeuds. La distribution des données par division de la scène est accomplie par division de la scène en
sous-environnements séparés par des barrières. Une communication entre les noeuds est
essentielle afin d’échanger la lumière entre les voxels d’une même liste présents sur plusieurs noeuds. Cette communication concerne en général le premier et le dernier voxel
de chaque liste non vide présents sur un noeud donné car c’est ces voxels qui peuvent
avoir des voisins en terme de visibilité localisés sur d’autres noeuds.
112
Les clusters utilisés pour la parallélisation sont des machines à mémoire distribuée.
Chacun des noeuds n’a alors aucune information sur les listes des voxels localisés sur les
autres noeuds et ignore alors les listes vides et non vides présents sur les autres noeuds.
Pour une liste donnée non vide, chacun des noeuds se trouve incapable de déterminer
l’identité du noeud avec lequel les informations d’illumination du premier et du dernier
voxel d’une liste donnée doivent être communiquées. Pour cela une première approche
peut être établie pour accomplir cette parallélisation. Chacun des noeuds, même s’il
ignore avec quel noeud les informations de chacune de ses listes doivent être effectuées,
peut envoyer les informations du premier et du dernier voxels de chacune de ses listes
non vides aux noeuds précédent et suivant. Ce n’est qu’au moment de la réception
des données par chacun des noeuds que le noeud peut décider s’il peut mettre à jour
la valeur d’illumination reçue ou si cette information doit être transférée de nouveau.
Une topologie cartésienne 1D (Figure 6.3) pour faciliter la communication est appliquée
entre les noeuds. Cette topologie facilite la procédure de communication entre les noeuds
directement voisins. Aussi des communications non bloquantes peuvent être menées pour
effectuer les envois et réceptions des données d’illumination.
Fig. 6.4 – Les étapes de la transmission entre les voisins pour une topologie cartésienne
6.3.2
113
Application de la parallélisation
L’application d’une topologie cartésienne 1D et des communications non bloquantes
pour effectuer la distribution des données par division de la scène peut être réalisée
comme suit.
Pour une direction donnée, chaque noeud remplit les informations du premier et
du dernier de chacune de ses listes non vides dans une structure de données libellée
par rapport au noeud suivant ou précédent. Une fois remplies, ces informations sont
envoyées au noeud précédent et suivant respectivement. Chacun des noeuds a le droit de
communiquer uniquement avec le noeud suivant ou précédent et ignore toute information
des listes vides ou non vides présentes sur les différents noeuds. C’est seulement au
moment de la réception des données par un noeud, que celui ci remarque que certaines
données ne peuvent pas être mise à jour, car la liste correspondante qui doit recevoir
la donnée est vide. A ce moment, le noeud doit re-transmettre cette information à
un noeud précédent ou suivant selon qu’elle provient du noeud suivant ou précédent
respectivement. Les informations à re-transmettre sont aussi stockées dans une structure
de données libellée par rapport au noeud suivant ou précédent. Les re-transmissions
continues jusqu’au moment où le premier et le dernier noeuds sont atteints ou si aucune
information n’est reçue par une liste non vide nécessitant une re-transmission. Toutes
les communications utilisées pour communiquer entre les noeuds sont non bloquantes
permettant à chacun des noeuds de faire son travail sans être obligé d’attendre que les
autres finissent un travail précédent.
Après toute les re-transmissions et la mise à jour de l’illumination des voxels, les
noeuds peuvent commencer à traiter la prochaine direction et la procédure continue.
La Figure 6.4 montre une scène distribuée sur 5 noeuds et les étapes des échanges
d’illumination entre les voxels pour une direction donnée. La première transmission
transmet la valeur d’illumination du premier voxel d’une liste donnée avec le noeud
précédent et du dernier voxel d’une liste donnée avec le noeud suivant. La deuxième
transmission concerne les informations qui n’ont pas pu être mise à jour car elles sont
reçues par des listes vides. Ces transmissions continues autant que nécessaire. Pour cet
exemple 3 transmissions sont suffisantes pour mettre à jour la valeur d’illumination des
voxels. Dans cet exemple, la liste (2, 2) est vide sur tous les noeuds à l’exception du
noeud 4, malgré cela les noeuds ne peuvent pas le savoir et l’information d’illumination
doit passer par tous les noeuds sans qu’elle soit mise à jour car les listes sont vides. Cela
correspond à un inconvénient de cette approche où les noeuds n’ont aucune information
sur les listes vides et non vides présentes sur les autres noeuds nécessitant le recours à
plusieurs transmissions avant d’arriver à mettre à jour l’illumination des voxels.
6.3.3
Résultats
Les résultats de cette parallélisation sont testés pour deux scènes, le scène de la cabine
et de l’église. Les tests sont effectués avec 4597 directions et 6 itérations. La Figure 6.5
114
montre la variation du temps en fonction du nombre de noeuds et la Figure 6.6 montre
l’accélération, une accélération de 3.5 est obtenue avec 10 noeuds.
4
600
3.5
3
Accélération
Temps (minutes)
500
400
300
2.5
2
200
1.5
100
0
1
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
Fig. 6.5 – Temps en fonction du nombre
de noeuds utilisant une topologie cartésienne et des communications non bloquantes
2
3
4
5
6
7
Nombre de noeuds
8
9
10
nombre de noeuds utilisant une topologie cartésienne et des communications
non bloquantes
Les Figures 6.7 et 6.8 montrent la distribution de temps des différentes opérations
de cette parallélisation pour les deux scènes, la scène de la cabine et la scène de l’église
respectivement. “Premier Echange” représente le temps de la première transmission des
données entre les noeuds, “Autres Echange” représente le temps pour les autres transmissions, et “Mise en place et propagation” représente le temps de la mise en place des
voxels dans leurs listes et la propagation de la lumière dans ces listes. Il est remarquable
que le temps de “Autres Echange” est zéro avec deux noeuds car une seule transmission
est suffisante. Ce temps augmente légèrement entre 3 et 4 noeuds et augmente encore
plus en allant de 5 à 10 noeuds. Concernant le temps du “Premier Echange”, ce temps
est grand au début et diminue quand le nombre de noeuds augmente car dans ce cas
il y a plus de probabilité de tomber sur des listes vides sur un noeud. Finalement le
temps de “Mise en place et propagation” est dépendant du nombre de noeuds et diminue
largement en fonction de celui-ci.
Il faut noter finalement que l’approche de division de la scène utilisant la topologie
virtuelle et les communications non bloquantes peut être intéressante dans le cas où la
plupart des listes présentes sur les noeuds ne sont pas vides nécessitant moins de transmissions entre les noeuds. Malheureusement ce n’est pas toujours le cas pour les scènes
en général, la plupart des fois plusieurs listes vides sont rencontrées nécessitant plusieurs
transmissions et diminuant ainsi la performance et l’efficacité de la parallélisation.
Premier Echange
Autres Echange
500
115
Premier Echange
Autres Echange
600
500
Temps (minutes)
Temps (minutes)
400
300
200
100
400
300
200
100
0
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 6.7 – Distribution du temps des différentes opérations utilisant une topologie cartésienne et des communications
non bloquantes pour la scène de la cabine
6.4
Fig. 6.8 – Distribution du temps des différentes opérations utilisant une topologie cartésienne et des communications
non bloquantes pour la scène de l’église
Approche par communications collectives
La division de la scène et l’application d’une topologie cartésienne ont pour but les
échanges juste entre les noeuds voisins directs. Or l’échange restreint entre les voisins
directs nécessite parfois le passage par plusieurs noeuds afin de transmettre l’illumination
entre deux voxels appartenant à une même liste mais situés sur deux noeuds écartés.
Cela amène à penser à transmettre la valeur d’illumination d’un voxel donné, au voxel
impliqué, sur le noeud impliqué, sans devoir passer par plusieurs noeud afin d’effectuer
le transfert. Une communication directe entre les noeuds peut être établie si chacun
des noeuds sait en avance avant les échanges, pour chacune des ses listes non vide, le
noeud avec qui l’information d’illumination doit être communiquée. Si ce processeur est
connu, l’information d’illumination désignée à un certains noeud est stockée et envoyée
au processeur en question. Chacun des noeuds doit alors obtenir l’information des listes
concernant tous les autres noeuds. Des communications collectives sont alors nécessaires
afin d’échanger ces informations locales sur chacun des noeuds et inaccessibles aux autres
à cause de l’utilisation des clusters à mémoire distribuée. Les différentes étapes de cette
parallélisation, ainsi que les résultats obtenus sont discutés ci-dessous.
6.4.1
Matrices de communication
Les listes de voxels construites pour le calcul de l’illumination globale sont caractérisées par deux entiers (i, j) représentant la partition de l’espace en droites discrètes
3D. La communication directe entre les noeuds implique que chacun des noeuds a des
informations concernant les listes vides et non vides présentes sur tous les autres noeuds.
Des communications collectives sont alors requises pour rassembler les informations sur
116
les listes de tous les noeuds. Une matrice booléenne peut être construite en représentant les listes vides par “0” et non vides par “1” (Figure 6.9 (a) et (b)). Or pour des
grandes scènes, l’intervalle (i1 ...in ) et (j1 ...jn ) peut subir des énormes variations et la
valeur maximale des i et j peut devenir large, ce qui rend coûteux le rassemblement des
matrices booléennes entre les noeuds. La construction d’une matrice contenant seulement la localisation des listes non vides est encore coûteuse en temps et en mémoire car
le nombre des listes non vides peut augmenter selon les scènes. Une solution possible
diminuant la complexité de cette procédure en temps et en mémoire est de construire
une matrice compressée des listes non vides. Les scènes ont généralement plusieurs listes
vides. Concernant les listes non vides, il y a une grande possibilité qu’elles soient localisées côte à côte car la localisation de ces listes dépend de la géométrie de la scène. Ceci
facilite la compression ; au lieu de spécifier un booléen par chacune des listes, décrivant
si la liste est vide ou non, ou de noter la localisation des listes non vides, il est possible de
construire une matrice compressée en notant pour une série de listes non vides localisées
côte à côte, la localisation de la première et la dernière de ces listes (Figure 6.9 (c)). Cela
permet de savoir le début et la fin d’une série de listes non vides sans maintenir la série
toute entière en mémoire. La Figure 6.10 montre l’effet de la compression sur le nombre
d’éléments de la matrice pour la scène de la cabine. Un facteur de compression de ≈ 150
est remarqué. Il est clair alors que le nombre d’éléments de la matrice diminue largement
après la compression. Une fois cette matrice compressée construite sur les noeuds, un
rassemblement de matrices est effectué. Le rassemblement consiste à faire une communication collective entre les noeuds rassemblant les matrices de communication de sorte
à obtenir toutes les matrices sur tous les noeuds. Notons que ces matrices compressées ne sont pas décompressées, une fois rassemblées, le travail sur ces matrices peut se
poursuivre sans avoir recours à une décompression. Après le rassemblement chacun des
noeuds possède les informations nécessaires concernant les listes vides et non vides de
tous les autres noeuds, il est alors capable de calculer à partir des matrices compressées,
pour chacune des listes non vide le noeud suivant et le noeud précédent avec lesquels
les informations d’illumination du premier et dernier voxel doivent être communiquées.
Pour cela deux matrices de communication sont calculées : une matrice précédente et une
matrice suivante, représentant le noeud précédent et suivant avec lesquelles le premier et
le dernier voxels de chacune des listes non vides, présentes sur un noeud donné doivent
communiquer. La Figure 6.9 (d) montre une exemple des 2 matrices de communication
trouvées sur le Noeud 2, les noeuds suivant et précédent sont juste trouvés pour les listes
non vides car pour les listes vides aucune communication n’est demandée.
117
Fig. 6.9 – Différentes étapes établies pour le calcul des matrices de communication. (a)
La scène initiale et la répartition des voxels dans les listes pour une direction donnée.
(b) Le calcul de la matrice des booléennes sur chacun des noeuds. (c) La compression
des matrices booléennes sur chacun des noeuds en mémorisant juste le numéro de la
première et dernière liste non vide pour une série contiguë des listes non vides. (d) Le
calcul des 2 matrices de communication sur le Noeud 2
118
200
180
Facteur de compression
160
140
120
100
80
60
40
20
2
3
4
5
6
Nombre de noeuds
7
8
9
Fig. 6.10 – L’effet de la compression sur les matrices de communications
6.4.2
Remplissage de voxels
Une fois les deux matrices de communication calculées par chacun des noeuds pour
une direction donnée, le remplissage des informations d’illumination des voxels impliqués
doit s’achever. Chaque noeud prend le voxel début et celui de fin de chacune de ces listes
non vides et vérifie vers quel noeud la valeur d’illumination doit être transférée. Si les
informations du voxels sont à transférer vers un autre noeud, celles-ci sont stockées dans
une structure de données libellée relativement au noeud de destination. Au contraire de la
distribution des données par répartition des listes (Chapitre 5), où le voxel devant quitter
le noeud est transféré tout entier, avec toutes les informations qu’il englobe (coefficient de
réflexion, illumination, coordonnée ...) vers le noeud destinataire, l’approche de division
de la scène ne nécessite que la transition de l’information du numéro de liste (i, j) et la
valeur d’illumination. Le numéro de liste va être utile pour préciser la liste impliquée
dans l’étape de mise à jour de l’illumination des voxels.
6.4.3
Envoi et Réception
Après avoir rempli les informations à envoyer, l’envoi et la réception des informations
d’illumination sont effectués. Ces envois et réceptions sont collectifs de tous les noeuds
vers tous les noeuds, transférant les données nécessaires à chacun des noeuds.
6.4.4
119
Mise à jour d’illumination
Les données reçues doivent être décodées afin de mettre à jour la valeur d’illumination des voxels. Les informations reçues comprennent la valeur d’illumination du voxel
impliqué et son numéro de liste (i, j). Ce numéro de liste permet de déterminer, sur un
noeud donné, avec quel voxel (du début ou de fin de la liste), les informations doivent
être échangées. L’étape finale est la mise à jour d’illumination des voxels impliqués.
6.5
Résultats et discussion
Les résultats de la distribution des données par répartition des listes ont été testés sur
le cluster Laic. Trois scènes sont utilisées pour les tests, la scène de la cabine, de l’église
et de la salle de travail. Les premiers tests consistent à utiliser 6 itérations et différents
nombres de directions pour les trois scènes. Un nombre de directions égal à 4597 est testé
pour toutes les scènes, 6271 directions pour la scène de l’église et 8209 pour la scène de
la salle de travail. Les temps de calcul pour chacune des trois scènes respectivement sont
montrés dans les Figures 6.11, 6.12 et 6.13. Il est possible de remarquer que le temps de
calcul diminue avec le nombre de noeuds.
500
1000
4597 directions
6271 directions
800
Temps (minutes)
Temps (minutes)
400
300
200
600
400
200
100
0
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
nombre de noeuds scène de la cabine
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
nombre de noeuds scène de l’église
Du point de vue accélération, la Figure 6.14 montre l’accélération en fonction du
nombre de noeuds des trois scènes en prenant un même nombre de directions (4597)
pour les trois scènes et 6 itérations. Il est possible de remarquer qu’une accélération de
≈ 6 est obtenue avec 10 noeuds.
Une description détaillée du temps de chaque opération de la parallélisation est montrée en Figure 6.15 et 6.16. Ces deux figures représentent respectivement la scène de la
cabine avec 4597 directions et la scène de la salle de travail avec 8209 directions. En
effet, l’algorithme séquentiel comprend deux temps de calcul qui sont importants, la
mise en place de voxels et la propagation de lumière dans les listes. Lors de la distribution des données par division de la scène, les mêmes opérations présentes en séquentiel
6
4597 directions
8209 directions
5
800
Accélération
Temps (minutes)
1000
120
600
4
3
400
2
200
0
1
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
nombre de noeuds scène de la salle de
travail
2
3
4
5
6
7
Nombre de noeuds
8
9
10
nombre de noeuds pour trois différentes
scènes
se répètent et le temps de ces opérations est divisé par le nombre de noeuds. En plus
d’autres opérations se rajoutent. Ces opérations sont le temps du calcul des matrices
de communication, de remplissage de voxels à envoyer, des envois et réceptions et de la
mise à jour de l’illumination des voxels.
Remplissage
Envoi et réception
Mise à jour
500
900
800
Temps (minutes)
Temps (minutes)
400
Remplissage
Envoi et réception
Mise à jour
1000
300
200
700
600
500
400
300
100
200
100
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 6.15 – Distribution temporelle en
fonction du nombre de noeuds utilisant
des communications collectives pour la
scène de l’église
0
1
2
3
4
5
6
7
Nombre de noeuds
8
9
10
Fig. 6.16 – Distribution temporelle en
fonction du nombre de noeuds utilisant
des communications collectives pour la
scène de la salle de travail
Il est clair que le temps de la mise en place et de la propagation de la lumière
dans les listes, le même calcul fait en séquentiel, est largement dépendant du nombre de
noeuds et diminue avec celui-ci. Concernant le temps des autres opérations, il ne varie
pas beaucoup et reste stable en augmentant le nombre de noeuds : cela vient du fait que
ce temps dépend du nombre de listes non vides qui détermine la quantité de données à
remplir, envoyer, recevoir et mettre à jour. Le nombre de listes non vides ne varie pas
Cabine
Nombre
de noeuds
1
2
3
4
5
6
7
8
9
10
Temps
528
282
215
170
152
132
121
108
103
95
Eglise
Efficacité
Temps
0,94
0,82
0,78
0,69
0,67
0,62
0,61
0,57
0,56
688
384
300
250
224
207
190
181
172
165
121
Salle de travail
Efficacité
Temps
Efficacité
0,9
0,77
0,69
0,61
0,55
0,52
0,48
0,44
0,42
572
314
242
200
180
162
152
142
134
128
0,91
0,79
0,715
0,64
0,59
0,54
0,5
0,47
0,45
TAB 6.1 – Etude de l’efficacité de la distribution des données par division de la scène
beaucoup quand le nombre de noeuds augmente ; ce qui engendre la stabilité en temps
des communications.
Un bon gain par rapport au nombre de noeuds est obtenu avec un nombre de noeuds
petit. Quand le nombre de noeuds augmente, ce gain diminue. Le tableau 6.1 montrant
les temps de calcul et les efficacités justifie cela. Une efficacité de 90% est remarquée avec
2 noeuds, cette efficacité diminue quand le nombre de noeuds augmente pour atteindre
une valeur de ≈ 45% avec 10 noeuds. En effet quand le nombre de noeuds augmente, on
continue à gagner sur les opérations de la mise en place des voxels et la propagation de
la lumière dans les listes, or pour les autres opérations rajoutées par la parallélisation,
le gain est négligeable car le temps de ces opérations est presque stable en augmentant
le nombre de noeuds.
6.5.1
Comparaison des deux approches de division de la scène
La Figure 6.17 montre une comparaison en temps de calcul des deux approches,
l’approche utilisant une topologie cartésienne et des communications non bloquantes et
l’approche utilisant des communications collectives. Les résultats sont testés sur deux
scènes différentes, la scène de la cabine et la scène de l’église utilisant 4597 directions et 6
itérations. Avec deux noeuds les deux approches fournissent plus ou moins les même résultats car les échanges sont limités et il n’y a pas besoin de plusieurs re-transmissions.
Quand le nombre de noeuds augmentent, l’approche des communications collectives
montre des meilleurs résultats en temps de calcul car elle permet une communication
directe entre les noeuds sans devoir passer par plusieurs noeuds pour transmettre l’information d’illumination d’un voxel donné au noeud en question.
122
Scène d’une cabine (collectives)
Scène d’une église (collectives)
Scène d’une cabine (topology)
Scène d’une église (topology)
600
Temps (minutes)
500
400
300
200
100
0
1
2
3
4
5
6
Nombre de noeuds
7
8
9
10
Fig. 6.17 – Comparaison des temps des deux approches de division de la scène, l’approche
utilisant une topologie cartésienne (topology) et l’approche utilisant des communications
collectives (collectives)
6.5.2
Parallélisation locale et distribution des données
Comme il a été noté en section 4.2, les deux étapes essentielles de calcul d’illumination
globale, la mise en place des voxels dans leurs listes de visibilité et la propagation de la
lumière dans ces listes peuvent être parallélisées localement en distribuant les voxels sur
différents threads.
La distribution des données par division de la scène divise la scène en plusieurs
parties chacune contenant un nombre plus ou moins équitable de voxels. Ces parties sont
distribuées sur les noeuds du cluster pour être traitées en parallèle. Chacun des noeuds
effectue alors, pour ses propres voxels, les deux étapes de calcul d’illumination, la mise
en place de ces voxels dans leurs listes et la propagation de la lumière dans les listes.
Ce n’est qu’après l’achèvement de ces deux étapes que les échanges des informations
d’illumination des voxels entre les noeuds peuvent commencer. Rien n’empêche alors
d’effectuer une parallélisation locale sur chacun des noeuds en distribuant les voxels
locale au noeud sur les threads. Cette parallélisation locale permet de profiter de toutes
les capacités des noeuds du cluster sur lequel la distribution des données est effectuée et
aide à maximiser la distribution des données par division de la scène. Cette parallélisation
a montré un gain de 20 à 25% par rapport à la distribution des données par division de
la scène.
123
Scène d’une cabine (division)
Scène d’une église (division)
Scène d’une salle de travail (division)
Scène d’une cabine (listes)
Scène d’une église (listes)
Scène d’une salle de travail (listes)
600
Temps (minutes)
500
400
300
200
100
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 6.18 – Temps en fonction du nombre de noeuds. Comparaison des deux approches
de distribution des données, par distribution des listes (listes) et par division de la scène
(division)
6.5.3
Comparaisons de distribution des données par répartition
des listes et par division de la scène
Les deux approches de parallélisation : la distribution des données par répartition de
listes et la distribution des données par division de la scène (communications collectives)
ont toutes les deux distribuées les données. Il est important finalement de comparer les
résultats de ces deux approches pour voir laquelle est la plus efficace du point de vue du
temps de calcul. Les Figures 6.18 et 6.19 permettent de comparer les deux approches.
Les tests sont effectués sur le cluster Laic. Trois scènes sont utilisées pour les tests, la
scène de la cabine, de l’église et de la salle de travail. Six itérations et 4597 directions
sont utilisés. Il est clair que l’approche de répartition des données par division de la scène
(division) donne des temps qui sont beaucoup plus rapide, presque deux fois plus rapide
que celle de distribution des données par répartition des listes (listes). En effet dans
l’approche de la division de la scène les voxels sont fixes sur les noeuds et ne transitent
pas entre les noeuds ce qui fait qu’il n’y a pas besoin d’un équilibrage de charge ni de
fusion de voxels reçus. Dans l’approche de répartition des listes, un déséquilibre entre
les noeuds nécessite un équilibrage ainsi qu’un remplissage d’un nombre important de
données entre les noeuds pour équilibrer la charge de nouveau. Cela n’est pas le cas pour
la division de la scène qui maintient en permanence un équilibre entre les noeuds.
124
6
Scène d’une cabine (division)
Scène d’une église (division)
Scène d’une salle de travail (division)
Scène d’une cabine (listes)
Scène d’une église (listes)
Scène d’une salle de travail (listes)
Accélération
5
4
3
2
1
2
3
4
5
6
Nombre de noeuds
7
8
9
10
Fig. 6.19 – Accélération en fonction du nombre de noeuds. Comparaison des deux approches de distribution des données, par distribution des listes (listes) et par division de
la scène (division)
Calculer l’ensemble de directions
Choisir l’ordre lexicographique
Pour (chaque voxel)
mettre le voxel dans la liste à laquelle il appartient
Fin Pour
Pour (chaque liste)
Construire la matrice compressée (numéro de listes vides et nonvides)
Fin Pour
Echanger la matrice compressée entre les noeuds
Trouver la matrice de communication
Remplir les données des voxels à envoyer
Faire les envois et réceptions entre les noeuds
Mettre à jour l’illumination des voxels
Vider les listes
Fin Pour
Fin Pour
Algorithme 6.2 – Calcul de l’illumination par division de la scène et utilisant des communications collectives
6.6
125
Cumul les données et communications collectives
Faire des communications entre les noeuds à chaque direction pour rassembler les
matrices de booléennes compressées ainsi que pour les échanges de voxels nécessite une
synchronisation entre les noeuds pour les envois et réceptions collectives. Ce temps de
synchronisation diminue parfois la performance de la parallélisation à cause de l’absence
d’une synchronisation. Cette désynchronisation entre les noeuds vient du fait que certains noeuds peuvent avoir plus de données à envoyer que d’autres, ayant un nombre
plus élevées de listes non vides. Ce temps de synchronisation, même faible, pour une
seule direction, se cumule sur les directions et est multiplié par le nombre d’itérations
engendrant un temps important au final. Une solution pour augmenter la performance
de l’approche de division de la scène consiste à augmenter la performance de la parallélisation en cumulant les données de plusieurs directions en mémoire pour les traiter plus
tard. Cela revient à mémoriser la matrice compressée de listes vides et non vides ainsi
que les informations d’illumination pour un certains nombre de directions. Cela pose des
limites mémoire, et doit tenir compte de la taille de la mémoire de chacun des noeuds.
En effet cumuler les données sur plusieurs directions oblige à stocker des données en mémoire et faire ensuite une phase de traitement des données pour achever la mise à jour
de l’illumination des voxels. L’Algorithme 6.2 montre l’algorithme de division de la scène
par communication collectives sans cumul des directions et l’Algorithme 6.3 montre le
même algorithme avec cumul des directions. Dans l’Algorithme 6.3, “maxcumul” indique
le nombre de directions pour lesquels on souhaite cumuler les données en mémoire. Une
variable “nombre de directions cumulées” valant zéro au début est incrémentée pour cumuler les données puis elle est remise à zéro quand le “nombre de directions cumulées”
vaut “maxcumul”.
L’avantage direct de cette approche consiste à diminuer le temps de synchronisation
en n’imposant une synchronisation que de temps en temps selon le nombre de directions
à cumuler. Cette approche a été testée mais malheureusement n’a pas réussi a diminuer
la synchronisation entre les noeuds. Ses résultats sont les mêmes qu’en prenant une
direction à la fois. Cela vient du fait qu’on cumule un nombre de directions limités, les
améliorations peuvent être obtenues avec un nombre de directions plus denses. Or quand
le nombre de directions est denses, la quantité d’informations cumulées en mémoire
devient très large et risque de ne plus tenir en mémoire RAM d’un ordinateur alors que
le but premier de la distribution des données est de diminuer la consommation mémoire
et non de l’augmenter.
126
Calculer l’ensemble de directions
nombre de directions cumulées=0
Choisir l’ordre lexicographique
Pour (chaque voxel)
Mettre le voxel dans la liste à laquelle il appartient
Fin Pour
Pour (chaque liste)
Mémoriser un pointeur du voxel début et fin de chaque liste non-vide
Vider les listes
Construire la matrice compressée (numéro de listes vides et nonvides)
Fin Pour
Incrémenter de 1 le nombre de directions cumulées
Si (nombre de directions cumulées==maxcumul)
Echanger la matrice compressée entre les noeuds
Trouver la matrice de communication
Remplir les données des voxels à envoyer
Faire les envois et réceptions entre les noeuds
Mettre à jour l’illumination des voxels
nombre de directions cumulées=0
Fin Si
Fin Pour
Fin Pour
Algorithme 6.3 – Calcul de l’illumination par division de la scène et utilisant des communications collectives. Les données sont cumulées en mémoire et les échanges sont effectués
chaque un ensemble de directions
6.7
Conclusion
Ce chapitre a traité de la distribution des données par division de la scène en utilisant deux approches différentes. La première approche de topologie cartésienne et des
communications non bloquantes effectue une communication entre les voisins directes
et nécessite parfois plusieurs transmissions pour mettre à jour la valeur d’illumination
des voxels voisins en terme de visibilité mais localisés sur des noeuds écartés. Cette approche a montré une performance inférieure à celle de la deuxième approche qui utilise
127
des communications collectives et établit des communications directes entre les noeuds.
Une comparaison entre les deux approches de distribution des données, par répartition des listes (Chapitre 5) et par division de la scène a été effectuée en comparant les
résultats obtenus pour différentes scènes. La parallélisation par division de la scène a une
meilleure performance que la méthode du chapitre précédent, à cause de la stabilité des
voxels sur les noeuds éliminant ainsi le recours à une équilibrage de charges. Aussi cette
approche offre l’avantage de maintenir l’ordre lexicographique des voxels qui ne transitent pas mais sont stables entre les noeuds. Elle ne requiert aucune fusion de données
reçues, car ces données ne sont pas des voxels mais des informations d’illumination à
mettre à jour. Les résultats obtenus utilisant la distribution des données par division de
la scène sont encourageant : une accélération jusqu’à 6 est obtenue avec 10 processeurs.
Dans le chapitre suivant, on propose une amélioration du calcul séquentiel et une
parallélisation de ces améliorations utilisant l’approche de division de la scène par communications collectives.
128
Chapitre 7
Améliorations de l’algorithme
séquentiel et sa parallélisation
L’algorithme séquentiel d’illumination globale [CM06] étudié au Chapitre 3 comprend deux étapes essentielles : la mise en place des voxels dans leurs listes et la propagation de la lumière dans les listes. Ces deux étapes ont une complexité linéaire. Différentes
parallélisations appliquées à cet algorithme (distribution locale, distribution du calcul
(Chapitre 4) et distribution des données (Chapitre 5 et 6)), permettent d’améliorer le
temps de calcul. Pour certaines scènes contenant des sources lumineuses intenses, une
étude précise des parallélisations nous a conduit à une analyse à postériori du code
séquentiel. Nous présentons dans ce chapitre les optimisations apportées à la version
séquentielle ainsi que leur conséquence en terme de parallélisation.
Nous avons remarqué que les deux étapes de calcul d’illumination peuvent être combinées en une seule, diminuant ainsi la complexité de l’algorithme. Ce chapitre explique
cette combinaison qui permet d’améliorer les performances de l’algorithme séquentiel.
Cette amélioration est testée sur plusieurs scènes, mesurant l’accélération offerte par cet
algorithme optimisé par rapport à l’ancien algorithme séquentiel.
Ce chapitre présente aussi une parallélisation de l’algorithme séquentiel amélioré.
Cette parallélisation est une distribution des données par division de la scène utilisant
l’approche des communications collectives, approche détaillée au Chapitre 6.
7.1
Amélioration de l’algorithme séquentiel
L’algorithme séquentiel d’illumination nécessite le calcul de l’ensemble de directions
ainsi que le tri des voxels en 4 ordres lexicographique. Ces calculs ne sont pas coûteux
car ils sont fait une seule fois indépendamment du nombre de directions et d’itérations.
Cet algorithme comprend cependant deux étapes essentielles et coûteuses en temps de
calcul se répétant à chaque direction, et pour toutes les itérations. Ces deux étapes sont
la mise en place des voxels dans les listes auxquelles ils appartiennent et la propagation
de la lumière dans ces listes. Elles nécessitent un parcours des voxels, le calcul des (i, j)
129
Chapitre 7. Améliorations de l’algorithme séquentiel et sa parallélisation
130
(partition de l’espace en droites), la mise en place des voxels un par un dans les listes
correspondantes et ensuite une propagation de la lumière entre les voxels voisins dans
une même liste. Ces étapes ne sont pas complexes en temps de calcul pour des petites
scènes mais quand les scènes augmentent en taille et par la suite en nombre de voxels,
elles demandent un temps de calcul important.
Dans [Cha06], Chatelier et Malgouyres considère que les voxels sont opaques, c’est-àdire n’ayant aucune transparence. Cela implique que la visibilité est 0 ou 1. Deux voxels
voisins en terme de visibilité, échange leur illumination.
Si deux voxels ne sont pas voisins en terme de visibilité, aucun échange ne se produit
entre eux.
Aussi, pour une direction donnée, au lieu d’avoir recours à une construction des listes
de voxels pour ensuite propager la lumière entre les voxels voisins en terme de visibilité
d’une même liste, il est possible d’éviter la construction des listes et de faire un échange
ou propagation de lumière surplace au moment du parcours des voxels. En effet cet
échange ne nécessite que de connaître un voxel par liste grâce à la propriété d’opacité.
En supposant que les voxels sont triés dans le bon ordre lexicographique, la propagation se fait de la manière suivante : pendant le parcours des voxels, le (i, j) du voxel
courant est calculé. La valeur d’illumination de ce voxel est échangée avec le dernier
voxel de la droite (i, j), en supposant que ce dernier a été sauvegardé en mémoire. Si
c’est pas le cas, cela implique que le voxel courant est le dernier voxel de la droite (i, j), il
n’a aucun antécédent et donc aucun échange de lumière n’est à faire. Après l’échange de
la lumière entre le voxel courant et son antécédent pour la droite (i, j), le voxel courant
est maintenu en mémoire comme étant le dernier visité de la droite (i, j). Le parcours
des voxels continue et la même procédure se répète pour tous les voxels.
La Figure. 7.1 montre un exemple de ce calcul. Les voxels sont parcourus dans l’ordre
lexicographique. En débutant le parcours, le voxel “a” est maintenu en mémoire comme
le dernier pour la droite (0, 0). Ensuite le voxel “b” est maintenu en mémoire comme le
dernier pour la droite (2, 2). En arrivant au voxel “c”, un échange de lumière entre les
deux voxels “c” et “a” appartenant à la même droite (0, 0) est effectué. Après cela le voxel
“a” est supprimé de la mémoire et le voxel “c” est maintenu en mémoire comme le dernier
voxel de la droite (0, 0). Le parcours continue : le voxel “d” est maintenu en mémoire
comme le dernier voxel pour la droite (0, 2) ; en arrivant au voxel “e”, un échange de
lumière est achevé entre celui-ci et le dernier pour la droite (2, 2), le voxel “b”.
7.1.1
Résultats
Des tests sont effectués sur le cluster Isima afin de comparer l’algorithme séquentiel amélioré expliqué en Section 7.1 et l’ancien algorithme séquentiel de Chatelier et
Malgouyres [Cha06] expliqué au Chapitre 3. Ces tests sont effectués sur trois scènes différentes : la scène d’une cabine, d’une église et d’une chambre composées respectivement
de 3.1 million et 3.5 million et 6 million de voxels. La Figure 7.2 montre les résultats
obtenus pour les 3 scènes utilisant 6 itérations et en variant le nombre de directions.
131
Fig. 7.1 – Propagation de la lumière surplace : le (i, j) de chacun des voxels est calculé, la
lumière est propagée entre le voxel courant et le dernier voxel de la droite (i, j). Ensuite
le voxel courant est maintenu en mémoire comme étant le dernier pour la droite (i, j)
Il est clair que l’algorithme séquentiel amélioré “(nouveau)” offre une accélération d’un
facteur de 1.55 à 1.7 par rapport à l’ancien algorithme séquentiel “(ancien)”. Cela montre
l’efficacité d’éliminer la construction des listes et faire la propagation surplace entre les
voxels d’une même droite (i, j), voisins en terme de visibilité.
7.1.2
Parallélisation locale
Une parallélisation locale peut être appliquée sur les améliorations effectuées à l’algorithme séquentiel d’illumination. L’algorithme séquentiel d’illumination [CM06] expliqué au Chapitre 3 contient deux étapes de calcul coûteux pour des grandes scènes
et qui peuvent être parallélisées localement utilisant des threads. Ces deux calculs sont
la mise en place des voxels dans leur listes correspondantes et la propagation de la
lumière dans les listes et qui peuvent être distribués parmi les threads, donnant à chacun des threads une partie des voxels à traiter. Comme l’algorithme séquentiel (ancien
algorithme), l’algorithme séquentiel amélioré (nouvel algorithme) peut être parallélisé
localement utilisant les threads. Or la parallélisation de l’algorithme séquentiel amélioré
est un peu différente de l’ancien algorithme, car il ne procède pas à la construction des
listes, l’échange de lumière entre les voxels est accompli surplace au moment du parcours
des voxels.
7.1.2.1
Étapes de la parallélisation locale
La parallélisation locale de l’algorithme séquentiel amélioré consiste à donner à chacun des threads une partie équitable des voxels, triés en ordre lexicographique (le tri est
choisi parmi les quatre tris pré-calculés). Chacun des threads calcule alors le (i, j) du
voxel et propage la lumière surplace. La propagation de lumière surplace comme vue en
132
4500
Scène d’une cabine (ancien)
Scène d’une église (ancien)
Scène d’une salle de travail (ancien)
Scène d’une cabine (nouveau)
Scène d’une église (nouveau)
Scène d’une salle de travail (nouveau)
4000
3500
Temps (minutes)
3000
2500
2000
1500
1000
500
0
2000
4000
6000
8000
10000
12000
14000
Fig. 7.2 – Temps en fonction du nombre de directions des deux algorithmes, l’algorithme séquentiel (ancien) et l’algorithme séquentiel amélioré (nouveau) testés sur trois
différentes scènes
Section 7.1 consiste, pour une droite (i, j), à maintenir en mémoire le dernier voxel de
la droite (i, j) et ensuite, mettre à jour la valeur d’illumination du voxel courant avec le
dernier voxel de la droite pendant le parcours les voxels. Or en distribuant les voxels sur
les threads, maintenir pour une droite (i, j) le dernier voxel seulement n’est pas suffisant.
Chacun des threads traite une partie des voxels, ce qui fait qu’à la fin de la propagation,
un échange de lumière des voxels appartenant à une même droite (i, j), mais traités par
différents threads, (et donc présents sur des structures de données distinctes) doit être
effectué. Cette mise à jour ne sera possible que si le tout premier et le dernier voxels
de chacune des droites sont maintenus en mémoire. Pour cela, au moment du parcours
des voxels, sur chacun des threads, le premier voxel de chacune des droites non vides
est gardé en mémoire en plus du dernier voxel de la droite et qui sera lui mise à jour
pendant le parcours.
A la fin du parcours le premier et dernier voxels de chacune des droites non vides sont
maintenus en mémoire. Une étape complémentaire consiste, pour toute droite (i, j) non
vide, à échanger la lumière entre le dernier voxel de la droite, présent sur une structure
de donnée désignée à un thread donné, avec le premier voxel de la même droite (i, j)
133
présent sur la structure de donnée désignée au thread suivant (voir Figure 7.3).
Fig. 7.3 – Chacun des threads maintient en mémoire le premier et le dernier voxel de
chacune des droites non vides. Un échange de lumière est accompli entre le dernier voxel
d’une droite (i, j) donnée désignée pour un thread donné, avec le premier voxel de la
même droite localisée sur le thread suivant
7.1.2.2
Résultats
Les résultats de la parallélisation locale de l’algorithme séquentiel amélioré sont montrés en Figure 7.4. Les tests sont effectués sur deux différentes scènes, la scène d’une
cabine et la scène d’une église avec, 6 itérations, deux threads et en variant le nombre
de directions. Deux threads sont utilisés car il a été remarqué que quand le nombre
de threads augmentent le temps augmente. Il est clair que cette parallélisation locale
a amélioré le temps de 5 à 15%. Il faut noter que l’application des threads sur l’algorithme séquentiel ancien a montré une amélioration du temps de 30% (Chapitre 4
Section 4.2.2.3), et donc les threads était plus performant sur cet algorithme que sur
l’algorithme amélioré. Cela est dû au fait que la parallélisation locale sur l’ancien algorithme séquentiel utilise les threads pour paralléliser les deux étapes la mise en place des
voxels dans leurs listes et la propagation de la lumière dans les listes. Or dans le nouveau
algorithme amélioré, ces deux étapes sont combinées en une seule et les listes ne sont
pas construites. Les threads sont alors appliqués sur une seule étape moins coûteuse, ce
qui a diminué leur performance.
7.1.3
Parallélisation des données par division de la scène
Comme a été expliqué au Chapitre 6 en Section 6.4, il est possible de diviser la
scène en plusieurs parties ou sous-environnement séparées par des barrières invisibles.
Les barrières sont placées de manière à respecter une densité équitable des voxels entre
les noeuds. Cette division de la scène permet alors la distribution des données entre les
noeuds des grappes de stations de travail. Or cette parallélisation a été appliquée sur
134
2000
Scène d’une église (sans thread)
Scène d’une église (2 threads)
Temps (minutes)
1500
1000
500
0
0
2000
4000
6000
8000
10000
12000
14000
16000
Fig. 7.4 – Temps en fonction du nombre de directions de l’algorithme séquentiel amélioré,
sans threads et avec deux threads (parallélisation locale). Les tests sont effectués sur deux
différentes scènes
l’algorithme séquentiel ancien proposé dans [CM06]. La même procédure peut être utilisée pour paralléliser l’algorithme séquentiel amélioré. L’algorithme séquentiel amélioré
se distingue par le fait que les listes ne sont pas construites pour effectuer la propagation
de lumière. Comme la parallélisation locale, la parallélisation par division de la scène,
nécessite une mémorisation des informations du premier et du dernier voxel de chacune
des droites non vides qui seront utiles pour la mise à jour de la lumière à chaque nouvelle
direction. Les informations nécessaires des deux voxels, le premier et le dernier de chaque
droite non vide, sont alors maintenus en mémoire. Ces informations sont ensuite remplies
et envoyées. Les informations reçues par chacun des noeuds sont utilisées afin de mettre
à jour la valeur d’illumination des voxels. Notons que la parallélisation appliquée est celle
de la division de la scène en utilisant des communications collectives (voir Section 6.4)
car elle a montré des meilleurs résultats en communiquant directement l’information du
voxel impliqué avec son voisin en terme de visibilité sur le noeud impliqué sans passage
par des noeuds intermédiaires.
7.1.3.1
135
Résultats
Les résultats de la distribution des données par division de la scène appliquée sur l’algorithme séquentiel amélioré et utilisant les communications collectives sont testés pour
trois scènes différentes, la scène d’une cabine, d’une église et d’une chambre composées
de 3.1 million et 3.5 million et 6 million de voxels respectivement. Les tests sont effectués
sur le cluster Isima avec 5000 directions pour la scène de la cabine, 8200 directions pour
la scène de l’église et 6300 pour la scène de la chambre et utilisant 6 itérations. Le temps
en fonction du nombre de noeuds est montré en Figure 7.5. L’accélération en fonction
du nombre de noeuds est montré en Figure 7.6 un gain de 4.5 est obtenu avec 10 noeuds.
2200
Scène d’une cabine (ancien)
Scène d’une cabine (nouveau)
Scène d’une église (ancien)
Scène d’une église (nouveau)
Scène d’une chambre (ancien)
Scène d’une chambre (nouveau)
2000
1800
1600
Temps (minutes)
1400
1200
1000
800
600
400
200
0
0
1
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 7.5 – Temps en fonction du nombre de noeuds de la distribution des données par
division de la scène appliquée sur l’algorithme séquentiel amélioré
7.2
Conclusion
Les améliorations apportées à l’algorithme séquentiel ont permis d’améliorer le temps
séquentiel par un facteur de 1.5. Cela est avantageux et permet de traiter de grandes
scènes plus rapidement. La parallélisation de l’algorithme séquentiel amélioré a apporté
136
6
Scène d’une chambre
5
Accélération
4
3
2
1
0
2
3
4
5
6
7
8
9
10
Nombre de noeuds
Fig. 7.6 – Accélération en fonction du nombre de noeuds de la distribution des données
par division de la scène appliquée à l’algorithme séquentiel amélioré
une minimisation du temps importante, tout en distribuant la mémoire permettant ainsi
de traiter de grandes scènes qui n’entrent pas en mémoire centrale d’un noeud.
Conclusion
Les méthodes de calcul d’illumination globale, spécifiquement les méthodes dérivées
de radiosité ou qui ont des points communs avec celle-ci, comme ce travail, simulent la
lumière d’une manière très précise permettant la génération d’images aussi réalistes que
possible. Ces méthodes demandent en général une puissance de calcul et une consommation mémoire importantes, ce qui nous a amené à nous intéresser à la parallélisation
de ces méthodes dans le but de réduire le coût de traitement.
Le présent document regroupe différentes parallélisations appliquées sur l’algorithme
d’illumination proposé par P. Chatelier et R. Malgouyres [CM06] “A low complexity
discrete radiosity method”. Les différentes parallélisations réalisées sont effectuées sur
des machines à mémoire distribuée, un cluster. Le choix d’une telle architecture nous
a permis non seulement de minimiser le temps de calcul, mais aussi la consommation
mémoire quand les données sont distribuées.
L’algorithme séquentiel d’illumination [CM06] est basé sur la discrétisation des surfaces en voxels pour le calcul d’illumination. La propagation de l’énergie s’effectue sur les
rayons. Des notions de géométrie discrète, notamment des droites discrètes sont utilisées
pour partitionner l’espace et propager la lumière entre les voxels. Le système d’équations linéaires de calcul de l’illumination est résolu par la méthode de Gauss-Seidel.
Cette méthode nécessite plusieurs itérations pour la convergence vers la bonne solution
d’illumination. L’algorithme séquentiel est dépendant d’un facteur de direction généré à
partir d’une sphère discrète. Dans ce travail, une étude de convergence effectuée sur cet
algorithme permet de tester la rapidité de convergence de l’algorithme en fonction des
deux facteurs qui sont le nombre d’itérations et de directions.
Dans un premier temps, nous avons minimisé le temps de calcul en appliquant une
parallélisation locale distribuant les voxels sur différents threads. Cette parallélisation est
locale à un noeud, elle a permis de diminuer le temps de calcul et d’augmenter le degré
ou le niveau du parallélisme, en se servant des deux bi-processeurs d’un noeud donné.
Une deuxième parallélisation qui distribue le calcul a été implémentée, distribuant les
directions de l’espace sur les différents noeuds du cluster. Bien que les résultats obtenus
soient très satisfaisants, cette distribution du calcul n’est pas envisageable lorsque les
scènes sont très grandes car elle ne distribue pas la mémoire mais nécessite une duplication des voxels sur les noeuds. Bref, ces deux parallélisations ont réussi à diminuer
le temps mais n’ont pas distribué la mémoire car elles nécessitent une duplication des
voxels sur les noeuds.
137
Conclusion
138
Le second objectif de minimisation du temps de calcul et la consommation mémoire
a été atteint. Le but essentiel était de distribuer les données et donc les voxels entre les
noeuds du cluster. Deux parallélisations ont été appliquées pour effectuer la distribution
des données. La première parallélisation a réparti les listes et donc les voxels parmi
les noeuds du cluster. Des échanges de voxels entre les noeuds ont été faits afin de
construire des listes complètes de voxels contenant tous les voxels appartenant à une
liste donnée. La deuxième parallélisation a divisé la scène en sous-environnements ayant
chacun un nombre équitable de voxels, les voxels sont stables entre les noeuds et seuls les
informations d’illumination des voxels voisins en terme de visibilité mais localisés sur des
noeuds distincts sont échangées. Cette deuxième parallélisation a montré de meilleurs
résultats par rapport à la première car elle ne demande pas un équilibrage de charge,
nécessite moins d’échanges entre les noeuds et requiert des opérations en parallèle moins
coûteuses que la répartition des listes.
La dernière partie de notre travail est une amélioration de l’algorithme séquentiel
d’illumination qui combine deux étapes du calcul d’illumination en une seule, minimisant
le temps de calcul séquentiel de 40% sur un seul processeur.
Toutes les parallélisations étudiées dans ce document sont appliquées sur l’algorithme
diffus d’illumination. Or cet algorithme a été étendu du cas diffus où la lumière émise
est la même dans toutes les directions au cas BRDF où l’énergie est émise dans une
direction donnée selon la direction incidente. Les parallélisations présentées dans cette
thèse sont adaptables au cas des BRDFs [CM07] ; la distribution des données par division
de la scène est mieux adaptée que la distribution des données par répartition des listes
car elle ne nécessite pas la communication du profil d’émission des voxels.
L’algorithme utilisant les BRDF [CM07] sera parallélisé dans une étape future en
étendant les méthodes de notre travail.
Il est important de noter finalement que cette approche d’illumination [CM06] que
l’on a parallélisé est une partie d’un algorithme de lancer de rayons en cours d’étude par
le doctorant Lukasz Piwowar. Cette méthode qui permet de réduire le coût en produisant
également un affichage non aliasé nécessitera aussi une parallélisation.
Annexe A
Scènes en 3D
Les images ci-dessous montrent une vue partielle des scènes en 3 dimensions. Ces
scènes sont utilisées pour tester les différentes parallélisations effectuées dans le présent
travail. Elles représentent les scènes initiales avant le calcul d’illumination.
Fig. A.1 – Scène d’une église
139
Annexe A. Scènes en 3D
140
Fig. A.2 – Scène d’une salle de travail
Fig. A.3 – Scène d’une chambre
141
Fig. A.4 – Scène d’une cabine
Fig. A.5 – Scène d’un salon
142
Bibliographie
[AAS97]
E. Andres, R. Acharya, and C. Sibata. Discrete analytical hyperplanes.
Computer Graphics Forum, 59(5) :302–309, 1997.
[Aaz96]
C. Aykanat, T.K. Çapin, and B. Özgüç. A parallel progressive radiosity
algorithm based on patch data circulation. Computers and Graphics,
20(2) :307–324, 1996.
[ACS00]
K. Atkinson, D.K. Chien, and J. Seol. Numerical analysis of the radiosity equation using the collocation method. Electronic Transactions on
Numerical Analysis, 11 :94–120, 2000.
[AFF97]
F.A. Agelet, F.P. Fontan, and A. Formella. Fast ray tracing for microcellular and indoor environments. IEEE Transactions on Magnetics,
33(2) :1484–1487, 1997.
[AJ97]
E. Andres and M.A. Jacob. The discrete analytical hyperspheres. IEEE
Transactions on Visualization and Computer Graphics, 3(1) :75–86,
1997.
[AK90]
J. Avro and D. Kirk. Particle transport and image synthesis. ACM
SIGGRAPH, Computer Graphics, 24(4) :53–66, 1990.
[Akl88]
S.G. Akl. The design and analysis of parallel algorithm. Prentice Hall,
1988.
[AMP00a]
D. Arquès, S. Michelin, and B. Piranda. A new geometrical support for
the radiosity function. High Performance Computer Graphics, Multimedia and Visualization (HPGC’2000), 1(1) :1–20, 2000.
[AMP00b]
D. Arquès, S. Michelin, and B. Piranda. Overlapping radiosity : using
a new function base with local disk support.
In 8th International
Conference in Central Europe on Computer Graphics and Visualization
(WSCG’2000), pages 236–243, Plzen, Czech Republic, February 2000.
143
BIBLIOGRAPHIE
[And00]
144
E. Andres. Modélisation analytique discrète d’objets géométriques. In
Habilitation à diriger des recherches, UFR Sciences Fondamentale et
Appliquées, Université de Poitiers (France), December 2000.
[And03]
E. Andres. Discrete linear objects in dimension n : the standard model.
Graphical Models, 65(1-3) :92–111, 2003.
[AS00]
M. Ashikhmin and P. Shirley. An anisotropic phong BRDF model. Journal of Graphics Tools, 5(2) :25–32, 2000.
[aSOaDWD98] M. Snir and S. Otto, S. Huss-Lederman and D. Walker, and J. Dongarra.
MPI : The Complete Reference (Vol. 1). MIT Press, 1998.
[BBK+ 68]
G.H. Barnes, R.M. Brown, M. Kato, D.J. Kuck, D.L. Slotnick, and R.A.
Stokes. The ILLIAC IV. IEEE transactions on computers, C-17(8) :746–
757, 1968.
[Bes01]
G. Besuievsky. A Monte Carlo approach for animated radiosity environments. PhD thesis, Universitat Polytècnica de Catalunya, 2001.
[Bla00]
C. Blaess. Programmation système en C sous Linux. Paris, 2000.
[BMP]
K. Bouatouch, D. Menard, and T. Priol. Parallel radiosity using a shared virtual memory. In Proc. of Advanced Techniques in Animation,
Rendering and Visualization.
[BW90]
D. Baum and J. Winget. Real time radiosity through parallel processing
and hardware acceleration. In Proceedings of the 1990 symposium on
Interactive 3D graphics, pages 67–75, Utah, United States, 1990.
[CAH00]
F. Cuny, L. Alonso, and N. Holzschuch. A novel approach makes higher
order wavelets really efficient for radiosity. Computer Graphics Forum
(Eurographics 2000 Proceedings), 19(3) :C99–108, 2000.
[CAP98]
X. Cavin, L. Alonso, and J.C. Paul. Parallel wavelet radiosity. In Proceedings of the Second Eurographics Workshop on Parallel Graphics and
Visualisation, pages 61–75, Rennes, France, 1998.
[Cav00]
X. Cavin.
Simulation numérique parallèle et graphisme haute-
performance pour la synthèse d’images réalistes. PhD thesis, Doctorat
de l’Institut National Polytechnique de Lorraine, 2000.
BIBLIOGRAPHIE
[CCWG88]
145
M.F. Cohen, S. Chen, J. Wallace, and D. Greenberg. A progressive refinement approach to fast radiosity image generation. Proceedings of the
15th annual conference on Computer graphics and interactive techniques,
22(4) :75–84, 1988.
[CG85]
M.F. Cohen and D.P. Greenberg. The hemi-cube : a radiosity solution
for complex environments. Computer Graphics, 19(3) :31–40, 1985.
[Cha06]
P. Chatelier. Une approche de la radiosité par voxels, application à la
synthèse d’images. PhD thesis, Doctorat de l’Université d’Auvergne,
2006.
[CM06]
P . Chatelier and R. Malgouyres. A low complexity discrete radiosity
method. Computer and Graphics, 30(1) :37–45, 2006.
[CM07]
P. Chatelier and R. Malgouyres. A fast interpolation method to represent
the BRDF in global illumination. In Grapp 2007, 2nd International
Conference on Computer Graphics Theory and Applications, pages 5–
12, Barcelona, Spain, March 2007.
[CMS98]
F. Castro, R. Martinez, and M. Sbert. Quasi monte-carlo and extended
first shot improvements to the multi-path method. In Proceedings of the
Spring Conference on Computer Graphics ’99, pages 91–102, Budimerce,
Slovakia, 1998.
[CNR92]
M. Cosnard, M. Nivat, and Y. Robert. Algorithmique parallèle. Masson,
Paris, 1992.
[CS99]
F. Capello and J.P. Sansonnet. Architectures parallèles, solutions. Technical Report ARCH7, H1100_11_1999, Laboratoire de recherche en informatique LRI et Université Paris Sud, Orsay, 1999.
[CT82]
L.R. Cook and E.K. Torrance. A reflectance model for computer graphics. ACM Transactions on Graphics, 1(1) :7–24, 1982.
[CT86]
L.R. Cook and E.K. Torrance. Stochastic sampling in computer graphics.
ACM Transactions on Graphics, 5(1) :51–72, 1986.
[CT93]
M. Cosnard and D. Trystram. Algorithmes et architectures parallèles.
InterEditions, Paris, 1993.
BIBLIOGRAPHIE
[CT97]
146
S. Coorg and S. Teller. Real-time occlusion culling for models with
large occluders. In Proceedings of the 1997 symposium on Interactive
3D graphics, pages 83–ff, Rhode Island, United States, 1997.
[Dam01]
C. Damez. Simulation globale de l’éclairage pour des séquences animées
prenant en en compte la cohérence temporelle. PhD thesis, Doctorat de
l’Université Joseph Fourier, Grenoble, 2001.
[DBB03]
P. Dutré, P. Bekaert, and K. Bala. Advanced global Illumination. A K
Peters, 2003.
[DDP97]
F. Durand, G. Drettakis, and C. Puech. The visibility skeleton : A
powerful and efficient multi-purpose global visibility tool. In SIGGRAPH
97 Conference Proceedings, Annual conference series, pages 89–100, New
York, NY, USA, 1997.
[DDP99]
F. Durand, G. Drettakis, and C. Puech. Fast and accurate hierarchical radiosity using global visibility. ACM Transactions on Graphics,
18(2) :128–170, 1999.
[Deg92]
G. Deghilage.
Architectures et programmation parallèles.
Addison-
Wesley, France, 1992.
[DHS04]
C. Damez, N. Holzschuch, and F. Sillion. Space-time hierarchical radiosity with clustering and higher-order wavelets. Computer Graphics
Forum, 23(2) :129–141, 2004.
[dR94]
J. de Rumeur. Communications dans les réseaux de processeurs. Masson,
1994.
[DR95]
I. Debled-Rennesson. Reconnaissance des droites et plans discrets. PhD
thesis, Doctorat de l’Université Louis Pasteur, 1995.
[Fes98]
F. Feschet. Techniques d’imagerie pour l’aide au positionnement en dosimétrie conformationnelle. PhD thesis, Doctorat de l’Université de Lyon
2, Lyon, 1998.
[FF97]
V.D. Foley and H. Feiner. Computer graphics - principles and practice,
2nd edition in C. Addison Wesley, 1997.
[Fle84]
C.A.J. Fletcher. Computational galerkin methods. Springer Verlag, 1984.
BIBLIOGRAPHIE
[Fly66]
147
M.J. Flynn. Very high speed computing systems. Proceedings IEEE,
54(12) :1901–1909, 1966.
[FMP98]
F. Feschet, S. Miguet, and L. Perroton. Parlist : a parallel data structure for dynamic load balancing. Journal of Parallel and Distributed
Computing, 51(2) :114–135, 1998.
[FP93]
M. Feda and W. Purgathofer. Progressive ray refinement for monte carlo
radiosity. In Proceedings of the 4th Eurographics Workshop on Rendering,
pages 15–26, Paris, France, Juin 1993.
[FSGS04]
S. Frenz, M. Schoettner, R. Goeckelmann, and P. Schulthess. Parallel
ray-tracing with a transactional DSM. In IEEE International Symposium on Cluster Computing and the Grid, pages 475–481. IEEE Computer Society, 2004.
[Fun96]
T.A. Funkhouser. Coarse-grained parallelism for hierarchical radiosity
using group iterative methods. In ACM SIGGRAPH ’96 proceedings,
pages 343–352, New Orleans, August 1996.
[FY97]
C. Feng and S. Yang. A parallel hierarchical radiosity algorithm for
complex scenes. In Proceedings of the IEEE symposium on Parallel rendering, pages 71–77, Arizona, United States, 1997.
[Gar99]
R. Garmann. On the partitionability of hierarchical radiosity. In Proceedings of the 1999 IEEE symposium on Parallel Visualization Graphics,
pages 69–78, California, United States, 1999.
[Gas66]
N. Gastinel. Analyse numérique linéaire. Hermann, 1966.
[GBD+ 94]
A. Geist, A. Beguelin, J. Dongarra, B. Manchek W. Jiang, and V. Sunderam. Pvm : Parallel virtual machine - a user’s guide and tutorial for
network parallel computing. Technical report, MIT Press, Cambridge,
Mass, 1994.
[GH96]
S. Gibson and R.J. Hubbold. Efficient hierarchical refinement and clustering for radiosity in complex environments. Computer graphics forum,
15(5) :297–310, 1996.
[GHLL+ 98]
W. Gropp, S. Huss-Lederman, A. Lumsdaine, E. Lusk, B. Nitzberg,
W. Saphir, and M. Snir. MPI : The Complete Reference (Vol. 2). MIT
Press, 1998.
BIBLIOGRAPHIE
[GL97]
148
W. Gropp and E. Lusk. Why are PVM and MPI so different ? In Proceedings of the 4th European PVM/MPI Users’ Group Meeting on Recent
Advances in Parallel Virtual Machine and Message Passing Interface,
pages 3–10, London, UK, 1997.
[GL02]
W. Gropp and E. Lusk. Goals guiding design : PVM and MPI. In Cluster Computing, 2002. Proceedings. 2002 IEEE International Conference,
pages 257–265, 2002.
[Gla89]
A. Glassner. An introduction to ray tracing. Morgan Kauffmann, 1989.
[GLDS96]
W. Gropp, E. Lusk, N. Doss, and A. Skjellum. A high-performance,
portable implementation of the MPI message passing interface standard.
Parallel Computing, 22(6) :789–828, 1996.
[GLS99]
W. Gropp, E. Lusk, and A. Skjellum. Using MPI : Portable Parallel
Programming with the Message-Passing Interface. MIT Press, 1999.
[Gou71]
H. Gouraud. Continuous shading of curved surfaces. IEEE transactions
on computer, c20(6) :623–629, 1971.
[Gou05]
M. Gouiffès. Apports de la couleur et des modèles de réflexion pour
l’extraction et le suivi de primitives. PhD thesis, Doctorat de l’Université
de poitiers, 2005.
[GRS92]
C. Germain-Renaud and J.P. Sansonnet. Les ordinateurs massivement
parallèles. Armand Colin, Paris, 1992.
[GRS95]
P. Guitton, J. Roman, and G. Subrenat. Implementation results and
analysis of a parallel progressive radiosity. In Proceedings of the IEEE
symposium on Parallel rendering, pages 31–38, Atlanta, Georgia, United
States, April 1995. ACM Press.
[GSCH93]
S.J. Gortler, P. Schröder, M.F. Cohen, and P. Hanrahan. Wavelet radiosity. In Proceedings of the 20th annual conference on Computer graphics
and interactive techniques, pages 221–230, 1993.
[GTGB84]
C. Goral, E. Torrance, D. Greenberg, and B. Bataille. Modeling the
interaction of light between diffuse surfaces. Computer Graphics (ACM
SIGGRAPH’84 Proceedings), 18(3) :213–222, 1984.
[GUD96]
M. Gengler, S. Ubéda, and F. Desprez. Initiation au parallélisme. Masson, Paris, France, 1996.
BIBLIOGRAPHIE
[GWS04]
149
J. Guenther, I. Wald, and P. Slusallek. Realtime caustics using distributed photon mapping. In Rendering Techniques 2004, Eurographics
Symposium on Rendering, pages 21–23, Norrkoping, Sweden, 2004.
[Han02]
O. Hansen. On the stability of the collocation method for the radiosity
equation on polyhedral domains. IMA Journal of Numerical Analysis,
22 :463–479, 2002.
[Han03]
O. Hansen. On the properties of the radiosity equation near corners.
PAMM, 2(1) :414–415, 2003.
[HCA00]
N. Holzschuch, F. Cuny, and L. Alonso. Wavelet radiosity on arbitrary
planar surfaces. In 11th Eurographics Workshop on Rendering, pages
161–172, Brno, Czech Republic, June 2000.
[HDSD99]
J.M. Hasenfratz, C. Damez, F. Sillion, and G. Drettakis. A practical analysis of clustering strategies for hierarchical radiosity. Computer
Graphics Forum (Proc. of Eurographics ’99), 18(3) :221–232, 1999.
[HS92]
P. Hanrahan and D. Saltzman. A rapid hierarchical radiosity algorithm
for unoccluded environments. In Photorealism in Computer Graphics,
Eurographics seminar series, 1992.
[HSA91]
P. Hanrahan, D. Saltzman, and L. Aupperle. A rapid hierarchical radiosity algorithm for unoccluded environments. Computer Graphics,
25(4) :197–206, 1991.
[HW91a]
E.A. Haines and J.R. Wallace. Shaft culling for efficient ray-cast radiosity. In Proceedings of 2nd Workshop on Rendering, pages 122–138,
1991.
[HW91b]
P. Heckbert and J. Winget. Finite element methods for global illumination. Technical Report UCB/CSD 91/643, Computer Science Division,
University of California Berkeley, 1991.
[JC95a]
H.W. Jensen and N.J. Christensen. Efficiently rendering shadows using
the photon map. In Compugraphics ’95, pages 285–291, 1995.
[JC95b]
H.W. Jensen and N.J. Christensen. Photon maps in bidirectional monte
carlo ray tracing of complex objects. Computer and Graphics, 19(2) :215–
224, 1995.
BIBLIOGRAPHIE
[Jen95]
150
H.W. Jensen. Importance driven path tracing using the photon map. In
P.M. Hanrahan and W. Purgathofer, editors, Rendering Techniques ’95,
pages 326–335. Springer-Verlag, 1995.
[Jen96]
H.W. Jensen. Rendering caustics on non-lambertian surfaces. In Graphics Interface ’96, pages 116–121, Toronto, Canada, 1996.
[Kel96]
A. Keller. Quasi-monte carlo radiosity. In Eurographics workshop on
Rendering techniques, pages 101–110, Porto, Portugal, 1996. SpringerVerlag.
[Kel97]
A. Keller. Instant radiosity. In 24th annual conference on Computer
graphics and interactive techniques, pages 49–56, 1997.
[KH95]
M.J. Keates and R.J. Hubbold.
Interactive ray tracing on a vir-
tual shared-memory parallel computer.
Computer Graphics Forum,
14(4) :189–202, 1995.
[KM99]
J. Kautz and M.D. McCool. Interactive rendering with arbitrary BRDFs
using separable approximations. In International Conference on Computer Graphics and Interactive Techniques ACM SIGGRAPH 99, page
253, New York, NY, USA, 1999.
[Kok93]
A.J. Kok. Grouping of patches in progressive radiosity. In Proceedings of
the Fourth Eurographics Workshop on Rendering, pages 221–231, Paris,
France, 1993.
[Kre89]
R. Kress. Linear integral equations. Springer Verlag, 1989.
[Lar04]
B.D. Larsen. Real-time global illumination by simulating photon mapping. PhD thesis, Technical University of Denmark, 2004.
[Lei91]
F.T. Leighton. Introduction to Parallel Algorithms and Architectures :
Arrays, Trees, Hypercubes. Morgan Kaufmann publishers, USA, 1991.
[LP00]
L. Leblanc and P. Poulin. Guaranteed occlusion and visibility in cluster
hierarchical radiosity. In Eurographics Workshop on Rendering 2000,
pages 89–100, June 2000.
[LW94]
E.P. Lafortune and Y.D. Willems. A theoretical framework for physically
based rendering. Computer Graphics Forum, Special Issue on Rendering,
13(2) :97–107, 1994.
BIBLIOGRAPHIE
[Mal02a]
151
R. Malgouyres. Algorithmes pour la synthèse d’images et l’animation
3D. Dunod, Paris, 2002.
[Mal02b]
R. Malgouyres. A discrete radiosity method. In Discrete Geometry
for Computer Imagery, pages 428–438, Bordeaux, France, April 2002.
Springer, Berlin, Germany.
[MB98]
D. Meneveaux and K. Bouatouch. Parallel hierarchical radiosity for
complex building interiors. Technical Report 3425, Rapport de recherche
INRIA, mai 1998.
[MB99]
D. Meneveaux and K. Bouatouch. Synchronisation and load balancing
for parallel hierarchical radiosity of complex scenes on a heterogeneous
computer network. Computer Graphics Forum, 18(4) :201–212, 1999.
[MBM97]
D. Meneveaux, K. Bouatouch, and E. Maisel. Memory management
schemes for radiosity computation in complex environments. Technical
Report RR-3149, Inria, 1997.
[MBSB03]
D. Meneveaux, K. Bouatouch, G. Subrenat, and P. Blasi. Efficient clustering and visibility calculation for global illumination. In AFRIGRAPH’2003 Proceedings, pages 87–94, Le Cap, Afirque du sud, February
2003.
[Men98]
D. Meneveaux. Simulation d’éclairage dans des environnements architecturaux complexes : approches séquentielle et parallèle. PhD thesis,
Doctorat de l’Université de Rennes I, 1998.
[Mig92]
S. Miguet. Redistribution élastique pour équilibrage de charge en imagerie. Masson, Paris, 1992.
[MMM+ ]
N. MacDonald, E. Minty, J. Malard, T. Harding, S. Brown, and M. Antonioletti. Writing message-passing parallel programs with MPI. Technical Report Course notes, Version 1.8.2, Edinburgh Parallel Computing
Centre, University of Edinburgh.
[MP97]
S. Miguet and J.M. Pierson. Heuristics for 1D rectilinear partitioning
as a low cost and high quality answer to dynamic load balancing. In
Proceedings of the International Conference and Exhibition on HighPerformance Computing and Networking, pages 550–564, Berlin/New
York, 1997. Springer Verlag.
BIBLIOGRAPHIE
[MR92]
152
S. Miguet and Y. Robert. Elastic load balancing for image processing
algorithms. In H.P. Zima, editor, Parallel Computation, LNCS 591, pages
438–451. Springer Verlag, 1992.
[MRR+ 53]
N. Metropolis, A.W. Rosenbluth, M.N. Rosenbluth, A.H. Teller, and
E. Teller. Equations of state calculations by fast computing machines.
Chemical Physics, 21(6) :1087–1091, 1953.
[Muu]
M.J. Muuss. Towards real-time ray-tracing of combinatorial solid geometric models. In BRL-CAD Symposium 95.
[Neu95]
L. Neumann. Monte carlo radiosity. Computing, 55(1) :23–42, 1995.
[NN85]
T. Nishita and E. Nakamae. Continuous tone representation of threedimensional objects taking account of shadows and interreflection. Computer Graphics (ACM SIGGRAPH’85 Proceedings), 19(3) :23–30, 1985.
[NPG03]
M. Nijasure, S. Pattanaik, and V. Goel. Interactive global illumination in dynamic environments using commodity graphics hardware. In
Proceedings of the 11th Pacific Conference on Computer Graphics and
Applications, page 450. IEEE Computer Society, 2003.
[Nus28]
W. Nusselt. Graphische bestimmung des winkelverhaltnisses bei der
warmestrahlung. In VDI Z, page 72 :673, 1928.
[Pac95]
P.S. Pacheco. A user’s guide to MPI. Technical report, University of
San Francisco, 1995.
[Pac96]
P. Pacheco. Parallel programming with MPI. Morgan Kaufmann publishers, 1996.
[PB94]
S.N. Pattanaik and K. Bouatouch. Fast wavelet radiosity method. Computer Graphics Forum, 13(3) :407–420, 1994.
[PBMH02]
T.J. Purcell, I. Buck, W.R. Mark, and P. Hanrahan. Ray tracing on
programmable graphics hardware. Computer Graphics Forum, Special
Issue on Rendering, 21(3) :703–712, 2002.
[Pho75]
B.T. Phong. Illumination for computer generated pictures. Communication of the ACM, 18(6) :311–317, 1975.
[PMS+ 99]
S. Parker, W. Martin, P.J. Sloan, P. Shirley, B. Smits, and C. Hansen.
Interactive ray tracing. In Interactive 3D Graphics (I3D), pages 119–126,
April 1999.
BIBLIOGRAPHIE
153
[Pér91]
B. Péroche. Les images de synthèse. Hermès, Paris, 1991.
[RAH07]
D. Roger, U. Assarson, and N. Holzschuch. Whitted ray-tracing for dynamic scenes using a ray-space hierarchy on the GPU. In Rendering
Techniques 2007 (Proceedings of the Eurographics Symposium on Rendering), pages 99–110, Grenoble, France, June 2007. the Eurographics
Association.
[RAPP97]
L. Renambot, B. Arnaldi, T. Priol, and X. Pueyo. Towards efficient
parallel radiosity for DSM-based parallel computers using virtual interfaces.
In Proceedings of the IEEE symposium on Parallel rende-
ring, pages 79–86, Phoenix, Arizona, United States, October 1997. ACM
Press.
[Rev91]
J.P. Reveillès. Géométrie discrète, calcul en nombres entiers et algorithmique. PhD thesis, Doctorat de l’Université Louis Pasteur, 1991.
[RF98]
L. Renambot and D. Figuls. Convergence analysis for a parallel radiosity algorithm using virtual interfaces. In Proceedings of the Second
Eurographics Workshop on Parallel Graphics and Visualisation, 1998.
[RGG90]
R. Recker, D. George, and D. Greenberg. Acceleration techniques for
progressive refinement radiosity. In Proceedings of the 1990 symposium
on Interactive 3D graphics, pages 59–66, Utah, United States, 1990.
[RP98]
J. Rappaz and M. Picasso. Introduction à l’analyse numérique. Presses
internationales polythechniques, 1998.
[RR97]
C. Renaud and F. Rousselle. Fast massively parallel progressive radiosity
on the mp-1. Parallel Computing, 23(7) :899–913, 1997.
[RS97]
J. Richard and J.P. Singh. Parallel hierarchical computation of specular
radiosity. In Proceedings of the IEEE symposium on Parallel Rendering,
pages 59–69, Arizona, United States, 1997.
[SAG94]
B. Smiths, J. Arvo, and D. Greenberg. A clustering algorithm for radiosity in complex environments. In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pages 435–442,
New York, NY, USA, 1994.
BIBLIOGRAPHIE
[Sbe93]
154
M. Sbert. An integral geometry based method for fast form-factor computation. Computer Graphics Forum (Eurographics’93), 12(3) :409–420,
1993.
[Sed01]
R. Sedgewick. Algorithmes en langage C. Dunod, Paris, 2001.
[SGL94]
J. Pal Singh, A. Gupta, and M. Levoy. Parallel visualization algorithms :
performance and architectural implications. IEEE Computer, 27(7) :45–
55, 1994.
[SH92]
R. Siegel and J.R. Howell. Thermal radiation heat transfer, 3rd Edition.
Hemisphere Publishing Corporation, New York, NY, 1992.
[SH00]
F. Sillion and J.M. Hasenfratz. Efficient parallel refinement for hierarchical radiosity on a DSM computer. In Third Eurographics Workshop on
Parallel Graphics and Visualisation, pages 61–74, Girona, Spain, 2000.
[Shi02]
P. Shirley. Fundamentals of computer graphics. A K Peters Ltd, 2002.
[SK01]
N. Stolte and A. Kaufman. Novel techniques for robust voxelization
and visualization of implicit surfaces. Graphical Models, 63(6) :387–412,
2001.
[SM03]
P. Shirley and R.K. Morley. Realistic ray tracing. A K Peters Ltd, 2003.
[SNSS97]
M. Stamminger, W. Nitsch, P. Slusallek, and H.P. Seidel. Isotropic clustering for hierarchical radiosity - implementation and experiences. In
Proceedings of the Fifth International Conference in Central Europe on
Computer Graphics and Visualization (WSCG ’97), pages 534–542, Plzen, Tcheque Republique, 1997.
[SP94]
F.X. Sillion and C. Puech. Radiosity and global illumination. Morgan
Kaufmann publishers, California, 1994.
[SPNP96]
M. Sbert, X. Pueyo, L. Neumann, and W. Pergathofer. Global multipath
monte carlo algorithms for radiosity. The Visual Computer, 12(2) :47–61,
1996.
[SWS02]
J. Schmittler, I. Wald, and P. Slusallek. Saarcor - a hardware architecture
for ray tracing. In Proceedings of the conference on Graphics Hardware,
pages 27–36, Saarbruecken, Germany, 2002. Eurographics Association.
[Tan91]
M. Tanenbaum. Structured computer organization. Prentice Hall, 1991.
BIBLIOGRAPHIE
155
[Tan05]
A. Tanenbaum. Architecture de l’ordinateur. Pearson Education, 2005.
[Tel93]
P. Tellier. Synthèse d’image réaliste : simulation d’éclairage intérieur et
extérieur mixte (naturel et artificiel). PhD thesis, Doctorat de l’Université de Rennes 1, 1993.
[TH93]
S. Teller and P. Hanrahan. Global visibility algorithms for illumination
computations. In Proceedings of the 20th annual conference on Computer
graphics and interactive techniques, pages 239–246, 1993.
[TNSP98]
R.F. Tobler, L. Neumann, M. Sbert, and W. Purgathofer. A new form
factor analogy and its application to stochastic global illumination algorithms.
In In Rendering Techniques ’98 (Proceedings of Eurogra-
phics Rendering Workshop), pages 35–44, New York, NY, USA, 1998.
Springer-Verlag.
[Vea94]
E. Veach. Bidirectional estimators for light transport. In Fifth Eurographics Workshop on Rendering, pages 147–162, Darmstadt, Germany,
1994.
[VG97]
E. Veach and L.J. Guibas. Metropolis light transport. In Turner Whitted, editor, SIGGRAPH 97, pages 65–76. Addison Wesley, August 1997.
[VP92]
A. Varshney and J.F. Prins. An environment-projection approach to
radiosity for mesh-connected computers. In Proceedings of the Third
Eurographics Workshop on Rendering, pages 271–281, Bristol, England,
1992.
[Wal04]
I. Wald. Realtime Ray Tracing and Interactive Global Illumination. PhD
thesis, Saarland University, 2004.
[War92]
G. Ward. Measuring and modeling anisotropic reflection. In Proceedings
of the 19th annual conference on Computer graphics and interactive techniques, pages 265–272, New York, NY, USA, 1992.
[WD96]
D.W. Walker and J.J. Dongarra. Message passing interface forum. MPI :
A message-passing interface standard. Supercomputer, 12(1) :56–68,
1996.
[Whi80]
T. Whitted. An improved illumination model for shaded display. Source
Communications of the ACM, 23(6) :343–349, 1980.
BIBLIOGRAPHIE
[WRC88]
156
G.J. Ward, F.M. Rubinstein, and R.D. Clear. A ray tracing solution
for diffuse interreflection. In 15th annual conference on Computer graphics and interactive techniques SIGGRAPH ’88, volume 22, pages 85–
92. ACM press, 1988.
[WSB01]
I. Wald, P. Slusallek, and C. Benthin. Interactive distributed ray tracing
of highly complex models. In 12th Eurographics Workshop on Rendering
Techniques, pages 277–285. Springer Verlag, 2001.
[YIY97]
Y. Yu, O.H. Ibarra, and T. Yang. Parallel progressive radiosity with
adaptive meshing.
Journal of Parallel and Distributed Computing,
42(1) :30–41, 1997.
[Zat93]
H.R. Zatz. Galerkin radiosity : a higher order solution method for global
illumination. In International Conference on Computer Graphics and
Interactive Techniques, pages 213–220, New York, NY, USA, 1993.
[ZCFM06]
R. Zrour, P. Chatelier, F. Feschet, and R. Malgouyres. Parallelization of
a discrete radiosity method. In Euro-Par, volume 4128, pages 740–750,
2006.
[ZFM06]
R. Zrour, F. Feschet, and R. Malgouyres.
Parallelization of a dis-
crete radiosity method using scene division. In Grid computing, highperformAnce and Distributed Applications, volume 4276, pages 1213–
1222, 2006.

Parallélisation d`une méthode d`illumination

Transcription

Documents pareils

LA CHAINE METEO Paris, le 22 avril 2001 Depuis ce matin, le vent

Maths en Jean, Lycée Pierre de Fermat

Le petit monde de l`Internet et des réseaux sociaux.

HATTERAS 48` Anno 1988 Motor Yacht Usato INFORMATION DE

PANNEAU MASSIF A 3 – PLIS

Beaute Qualite - Goodfellow Inc.

Autodesk 3D Studio Max

Artlantis : la version R

Mes listes GTD - oseaformation.com