Dans la section précédente, nous avons présenté les éléments qui caractérisent la cohérence d’une connexion ctin que nous avons notée Fs(I′,t) → Fd(I,t). La boucle, le sens de la boucle,
l’ordonnancement des fonctions de base et le vecteur distance d sont les acteurs du processus de vérification. La vérification de la cohérence globale des directives order, revient à tester la cohé-rence de chaque directive ctin. L’algorithme analyse chaque connexion indépendamment. D’autre part, en tenant compte de la remarque précédente, nous savons que toute directive ctin qui vérifient
dt 6= 0 est cohérente. C’est pourquoi, nous nous limitons à la vérification de cohérence des
4.3. ALGORITHME DE COHÉRENCE
dans la suite par la connexion générique Fs(I′) → Fd(I), I′ et I étant la localisation dans les es-paces S′et S qui ne sont pas de même dimension. Etant donné que la dimension de S′est toujours inférieure ou égale à celle de S (S′ ⊂ S), nous avons noté ˆI la projection de I sur les axes de S′. Puisque nous considérons uniquement les références relatives, le vecteur distance I′− ˆI a la même
dimension que S′ et sa composante suivant un axe l est égale à la distance algébrique dl. Ainsi, si S′ est de dimension 1, alors I′− ˆI = (dl), si elle est de dimension 2, alors I′− ˆI = (dl, dm), où l, m ∈ i, j,k, et si elle est de dimension 3, alors I′− ˆI = (di, dj, dk).
Pour introduire l’algorithme de cohérence, nous présentons en figure 4.4 un exemple de di-rectives order. Dans cet exemple, l’utilisateur spécifie trois blocs de didi-rectives order. Chaque
order YA1 A order YA2 B C order YA2 order YA1 D order YB3 E order YA3 F order YB2 order YB3 order YA1 G
FIG. 4.4 – Exemple de directives order, directives définies par l’utilisateur. Les fonctions de base
E, F, G sont rattachées à des espaces à trois dimensions, B,C, D à des espaces à deux dimensions
et A à un espace à une dimension.
bloc se réfère à un espace dans lequel les fonctions de base associées à cet espace peuvent être calculées. Ainsi, cette séquence de blocs order divise l’ensemble total des fonctions de base en sous-ensembles disjoints. L’ordre de calcul des blocs est donné par l’ordre de déclarations de l’utilisateur. Dans l’exemple, le calcul de la procédure forward commence par le calcul du bloc contenant A, B et C ; ensuite le bloc qui contient les fonctions de base D, E et F est calculé ; en-fin le bloc de la fonction de base G termine le calcul de la procédure. Chaque bloc de directives
order est composé par une boucle extérieure, décrite par le paramètre Y X l, avec X ∈ {A,B} et l∈ {1,2,3} qui correspond à {i, j,k}. Le corps de la boucle extérieure est composé de trois types
de listes d’instructions : – une liste de boucles,
– une liste de fonctions de base,
t
YA1 YA2 YB2
YA2 A B C YA1 YB3 E YA3 D F YB3 YA1 G niveau 1 niveau 2 niveau 3 niveau 4 1 1 1 1 3 2 1 1 1 1 1 1 2 2 2 3
FIG. 4.5 – Cette arborescence correspond aux directives order de la figure 4.4. Les feuilles repré-sentent les fonctions de base et tous les autres nœuds (les nœuds internes) reprérepré-sentent les boucles, ils sont caractérisés par leurs paramètres Y X l. Tous les nœuds, sauf la racine, se caractérisent par
num_ f ils.
Comme dans la théorie de la compilation [Aho et al., 2006], il est possible d’organiser des directives order par un Abstract Syntax Tree (AST). On appellera cet AST arbre de directives
order. Les nœuds fils de la racine sont les order extérieurs (trois dans l’exemple) ; ces nœuds
correspondent au niveau 1 (la racine étant au niveau 0). Le développement de l’arbre continue à partir de ces nœuds fils. D’une manière générale, chaque nœud de l’arborescence correspond à une instruction. Cette instruction peut être soit une boucle relative à une directive order, soit le calcul d’une fonction de base. Un nœud qui calcule une fonction de base n’a pas de fils et correspond donc à une feuille de l’arbre. Un nœud qui correspond à une boucle aura autant de fils que d’instructions dans sa boucle, ces fils seront situés dans le niveau consécutif au niveau du père (niveau du père +1).
Dans cette représentation, les fonctions de base sont les feuilles de l’arbre, et chaque nœud interne (nœud qui n’est pas une feuille ou la racine) représente une boucle définie par son axe et son sens. Puisque la version actuelle de YAO ne permet qu’un maximum de trois dimensions pour un espace, l’arborescence a au plus 4 niveaux, étant donné que la racine est le niveau 0. Les fils d’un nœud sont numérotés (à partir de 1) dans l’ordre de leur déclaration par l’utilisateur. Nous noterons par la suite ce numéro num_ f ils. Un nœud interne de l’arborescence contient le paramètre
Y X l (X∈ {A,B} et l ∈ {1,2,3}), qui spécifie l’axe et le sens de la boucle. Une feuille contient le
nom de la fonction de base. La figure 4.5 montre l’arborescence relative à l’exemple précédent (figure 4.4).
4.3. ALGORITHME DE COHÉRENCE
Avec cette représentation, si nous voulons caractériser les boucles imbriquées qui contiennent le calcul d’une fonction de base, il suffit de déterminer le chemin de la racine à la feuille qui re-présente la fonction de base. Les nœuds internes de ce chemin rere-présentent les boucles imbriquées qui permettent le calcul de la fonction de base. Si nous ne considérons pas la racine, le premier nœud du chemin correspond à la boucle extérieure et le dernier nœud correspond à la fonction de
base. Ainsi, pour chaque fonction de base, nous pouvons créer une liste qui représente le chemin,
composé au plus de 3 nœuds internes intermédiaires. Chaque nœud interne contient les champs suivants :
– num_ f ils, ordre de gauche à droite de la déclaration des frères à l’égard du nœud parent, – axe, indice de la boucle (axe∈ {i, j,k}),
– sens, ascendant ou descendant de la boucle.
L’axe et le sens sont représentés dans la figure par le paramètre Y X l. Avec cette arborescence, on peut vérifier la cohérence d’une directive ctin particulière. L’algorithme 4 explique le processus de cohérence.
Nous nous limitons ici à l’explication de l’idée générale en présentant quelques exemples d’exécution de l’algorithme de vérification. L’objectif de l’algorithme de cohérence est de détecter les incohérences sur les directives order, en supposant que les directives ctin sont globalement cohérentes. Nous allons discuter de l’incohérence des directives ctin au chapitre suivant.
À titre d’exemple, on montre une exécution de l’algorithme. Nous testons la cohérence de la connexion B(i − 1, j) → C(i, j), où di= −1 et dj = 0, sur l’arbre de figure 4.5. La figure 4.6a
montre les chemins Cbet Cc pour les fonctions de base B et C, ils ont trois niveaux, n= 3. A la
(c) t YA1 YA2 B C niveau 1 niveau 2 niveau 3 niveau 4 1 1 2 2 t YA1 YA2 A B 1 1 1 2 t YA1 YB2 YA2 C YB3 YA1 G 1 1 3 1 1 2 2 (a) (b)
FIG. 4.6 – Trois exemples de chemins Cs et Cd pour l’arbre de la figure 4.5 et les fonctions de
base : (a) B et C ; (b) C et G ; (c) A et B.
Algorithme 4 Vérification de la cohérence des directives order par rapport à une directive ctin. ENTRÉES: On note Fs(I′,t′) → Fd(I,t) la connexion qui représente la directive ctin. dl est la
composante du vecteur I′− ˆI relativement à l’axe l.
SORTIES: vrai si le ctin est cohérent, faux autrement. 1: si dt≤ 0 alors
2: retourner vrai 3: finsi
4: Trouver les deux chemins Cset Cd de la racine aux feuilles Fset Fd. 5: Soit n la longueur minimale de Cset Cd.
6: pour m= 1 à n faire
7: Déterminer au niveau m les deux nœuds Nset Nd de l’arbre qui sont situés respectivement sur les deux chemins Cset Cd.
8: //Les deux nœuds Nset Ndsont soit confondus soit deux frères. 9: si num_ f ils de Ns< num_ f ils de Ndalors
10: retourner vrai
11: finsi
12: si num_ f ils de Ns> num_ f ils de Ndalors
13: retourner faux
14: finsi
15: //A ce stade, num_ f ils de Ns= num_ f ils de Nd. Les deux nœuds sont identiques et corres-pondent à une boucle.
16: Soit l l’axe relatif à la boucle commune. 17: si dl 6= 0 alors
18: retourner le résultat de la règle 2. 19: finsi
20: // On continue la boucle au niveau successif ce qui correspond à l’application de la règle 3. 21: m← m + 1
22: fin pour
23: retourner faux
conditions des lignes 9 et 12 de l’algorithme 4 sont faux, nous sommes dans la même boucle. Puisque sens= ascendant et di < 0, la règle 2 de la ligne 18 a comme résultat que le ctin est
cohérent, donc l’algorithme se termine en retournant vrai.
En deuxième exemple (figure 4.6b), nous testons la cohérence de la connexion C(i + di, j + dj) → G(i, j), où diet dj ont une valeur quelconque. Cset Cd, montrés en figure 4.6b, ont respec-tivement 3 et 4 niveaux. A la première itération m= 1, le num_ f ils de Nset Nd ont respectivement les valeurs 1 et 3, ce qui rend vraie la condition à la ligne 9. En effet, C et G ont respectivement
i et j comme boucles extérieures, les fonctions de base n’appartiennent pas à la même boucle de
niveau 1. Puisque le num_ f ils de Ns est inférieur au num_ f ils de Nd, l’algorithme retourne vrai (il est évident que si l’on cherchait à vérifier la connexion G(i + di, j + dj) → C(i, j) l’algorithme