C.3 Lancement et exécution d'une configuration

Figure: Les quatre phases du processus de lancement d'une configuration.

Le lancement d'une configuration d'entrée consiste en un ensemble d'opérations destinées à préparer cette configuration d'entrée à l'exécution. Ces mécanismes aboutissent à la création d'une machine réactive, qui sera la version exécutable de la configuration d'entrée. Les différentes étapes de ce processus, illustrées sur la figure C.3 pour une configuration-exemple, sont les suivantes:

1. Aplatissement de l'arbre des configurations
2. Création des valeurs et ouverture des dispositifs
3. Tri topologique
4. Création de la machine réactive

La première phase consiste à aplatir l'arbre des configurations afin de placer tous les dispositifs au même niveau. L'algorithme, appelé décomposition totale, a déjà été décrit en annexe A (algorithme algo:composition). La seconde phase consiste à créer les structures de base qui serviront à l'exécution: les Valeurs (signaux valués) et les Processeurs. Un tri topologique est ensuite effectué sur les processeurs, à partir du graphe de dépendances entre dispositifs ( $\rightarrow$ section A.3.5). La dernière phase consiste à construire la machine réactive et remplir sa structure.

Nous ne décrirons pas le mécanisme d'aplatissement (déjà décrit en Annexe A) et le tri topologique (déjà connu [Lacomme et al., 2003]). En revanche nous détaillerons la phase consistant à créer les « structures de base », après avoir décrit ces structures. Puis nous décrirons les machines réactives et la façon dont elles sont créées.

C.3.1 Codage des signaux d'entrée et des processeurs

Dans la section précédente, nous avons introduit et décrit les processeurs à l'aide d'outils mathématiques simples. Dans cette partie, nous emploierons des représentations alternatives sous forme de structures de données.

Un signal valué est codé par une structure nommée Valeur, qui encapsule une valeur de variable et un temps. Le temps est un entier précisant à quel moment le signal valué a reçu un signal pour la dernière fois. Cette représentation est équivalente à celle des signaux valués vus précédemment: un signal est présent ($s=vrai$) si et seulement si le temps de la Valeur est égal au temps courant de la machine réactive (i.e. au temps global).

La structure Valeur est décrite ci-dessous:

Tableau C.1: Structure d'un signal valué.

	parent		Machine
	valIndex		entier
	valeur		variable
	temps		entier
	signal		vrai/faux

$\blacksquare$ #1 :

La machine réactive à laquelle appartient cette Valeur.

$\blacksquare$ #1 :

Spécifie l'indice de cette Valeur dans la machine réactive.

$\blacksquare$ #1 :

La valeur de variable du signal valué, stockée dans une variable au sens langage de programmation. La représentation concrète de cette variable dépend du type du slot associé, ainsi que du langage de programmation choisi pour l'implémentation. Nous ne nous en préoccupons pas ici.

$\blacksquare$ #1 :

Le temps associé à la Valeur, spécifiant à quel moment elle a reçu un signal pour la dernière fois.

$\blacktriangleright$ #1 :

Attribut booléen dérivé spécifiant si un signal est présent. Cet attribut vaut vrai ssi le temps de la valeur est égal au temps de la machine réactive parente.

Un processeur est codé par une structure Processeur. Cette structure comporte des références à des Valeurs d'entrée et de sortie, ainsi qu'une décomposition de $P_{E, S}$ en deux séries de fonctions nommées $calculValeur$ et $calculSignal$. Ces fonctions sont des projections de la fonction $P_{E, S}$ sur les valeurs et les signaux de son ensemble d'arrivée:

   Soit $P_{E,S}: h^t(E) \mapsto v(S) = \bigl \langle \langle x_1, s_1 \rangle, \dots, ... ... calculValeur[i]: h^t(E) \mapsto x_i \\ calculSignal[i]: h^t(E) \mapsto s_i$

Tableau C.2: Structure d'un processeur.

	entrées		Valeur [ ]
	sorties		Valeur [ ]
	$calculValeur$		fonction [ ]
	$calculSignal$		fonction [ ]

$\blacksquare$ #1 :

Cette table contient les Valeurs représentant les signaux d'entrée du processeur.

$\blacksquare$ #1 :

Cette table contient les Valeurs représentant les signaux de sortie du processeur.

$\blacksquare$ #1 :

Les projections de la fonction $P$ sur les valeurs de variable de chaque signal de sortie. Cette table comporte autant de fonctions que d'éléments dans la table valeursSortie.

$\blacksquare$ #1 :

Les projections de la fonction $P$ sur les signaux de chaque signal de sortie. Cette table comporte autant de fonctions que d'éléments dans la table valeursSortie.

C.3.2 Création des valeurs et ouverture des dispositifs

La seconde étape phase du lancement d'une configuration d'entrée consiste à créer les structures contenant les valeurs des slots.

Une structure Valeur est créée pour tout slot de sortie de la configuration d'entrée. Les slots d'entrée ne comportent pas de Valeur (voir la figure C.3), mais référencent celle de leur slot connecté. Il n'y aura donc pas à proprement parler de propagation de valeur entre deux slots, puisque ceux-ci partageront la même valeur.

Une fois les valeurs créées, les dispositifs sont ouverts: lorsqu'un dispositif est ouvert, celui-ci retourne une structure Processeur créée à partir de sa fonction d'exécution.

C.3.3 Construction de la machine réactive

Figure: Exemple de machine réactive créée à partir d'une configuration exemple.

La machine réactive gère tous les aspects de l'exécution des configurations d'entrée, et en particulier le déclenchement des processeurs et la propagation des valeurs. Un exemple de structure de machine réactive est illustré sur la figure C.4, qui reprend la configuration-exemple de la figure C.3. Cette structure est la suivante:

Tableau C.3: Structure d'une machine réactive.

	ProcInfo		(Processeur, vrai/faux, vrai/faux) [ ]
	ValInfo		(Valeur, entier, entier) [ ]
	DepInfo		vrai/faux [ ]
	temps		entier

$\blacksquare$ #1 :

Cette table contient une liste topologiquement ordonnée des processeurs avec leurs conditions de déclenchement. Le booléen actif spécifie si le processeur doit être continuellement déclenché. La valeur de cet attribut dépend de la nature de la fonction $P_{E, S}$ du processeur ( $\rightarrow$ section C.2.4). Le second booléen, déclenché est interne à l'algorithme d'exécution. Initialement égal à actif, il servira à spécifier pour l'itération courante si les valeurs du processeur doivent être mises à jour.

$\blacksquare$ #1 :

Cette table contient la liste des Valeurs ainsi que leurs dépendances (illustrées sur la figure C.4 par des flèches pleines). Les dépendances d'une Valeur sont définies par les attributs depFirst et depLast, qui référencent par leur index un ensemble d'éléments contigus dans la table DepInfo.

$\blacksquare$ #1 :

Cette table contient la liste des dépendances référencées par OutInfo, et est remplie en même temps qu'elle. Lorsqu'un slot de sortie est traité par l'ajout d'une Valeur dans OutInfo, une dépendance est créé pour chaque slot d'entrée qui lui est directement connecté. Une dépendance est uniquement décrite par l'attribut ProcIndex, qui référence le processeur du dispositif parent du slot d'entrée, en pointant vers son index dans la table ProcInfo.

$\blacksquare$ #1 :

Cet attribut est interne à l'algorithme d'exécution au même titre que l'attribut déclenché de la première table. Initialement à zéro, ce compteur entier spécifiera le temps courant de la machine réactive.