}
NJN_DEF_COMPONENT(demux){
njn_new(self, "vector", "in", NJN_ELEMTYPE("var"), NJN_INPUT);
njn_new(self, "var", "out0", NJN_OUTPUT);
...
}
Un mux (respectivement un demux) comporte toujours une entrée (respectivement une sortie) non-connectée. Lorsqu'on lui connecte une variable, le pseudo-composant en crée une nouvelle et adapte automatiquement la taille du vecteur de sortie. La modification est répercutée sur l'ensemble du réseau.
njn_ref_t v = njn_new(self, "vector", "v", ...);
njn_ref_t m = njn_new(self, "mux", "m", ...);
njn_ref_t e0, e1;
NJN offre des mécanismes de description générique de code très puissants basés sur les vecteurs et des blocs de génération.
Le modèle de graphe flot de données factorisé décrit par Lavarenne [48] permet de factoriser un schéma structurel répétitif au sein d'un graphe flot de données.
122 - Chapitre 5
L'objectif poursuivi par Lavarenne est d'optimiser l'utilisation de ressources matérielles limitées [20]. Le nôtre est bien différent puisque nous cherchons à généraliser un schéma structurel en fonction de vecteurs de données dont la taille peut évoluer dynamiquement au cours du temps. Mais le modèle qu'il propose répond parfaitement à notre problème.
Figure 50. Décomposition et factorisation d'un produit scalaire (source [48]).
Il repose sur le placement de frontières de factorisation qui assurent la synchronisation des opérateurs factorisés (à l'intérieur de la frontière) avec l'extérieur de la frontière. Des opérateurs spécifiques gèrent la synchronisation des données à travers la frontière :
• Un opérateur D (diffuse) diffuse la même donnée pour chaque itération de la zone factorisée ;
• Un opérateur F (fork) multiplexe chaque élément d'un vecteur de données à une itération de la zone factorisée ;
• Un opérateur I (iterate) réinjecte à chaque itération une donnée de l'itération précédente ;
• Un opérateur J (join) démultiplexe les données produites par toutes les itérations au sein d'un vecteur de sortie.
Lavarenne donne l'exemple de la décomposition du produit scalaire de deux vecteurs (figure 50). L'algorithme de calcul du produit scalaire est un schéma répétitif. Les résultats de la multiplication terme à terme des vecteurs d'entrée sont sommés pour former la donnée de sortie. Sa factorisation consiste à placer un multiplexeur (opérateur F) sur chaque vecteur d'entrée et un itérateur (opérateur I) pour réaliser la somme des différents produits.
NJN propose un mécanisme similaire pour décrire des structures répétitives et auto-adaptatives. Cela passe par la définition d'un bloc (generate) dont le contenu peut être reproduit pour chaque élément d'un ou plusieurs vecteurs de même taille.
Le schéma de factorisation est directement induit par les opérateurs de frontières si
Le modèle de reconfigurabilité et le modèle de distribution - 123 apparaissant dans la définition du bloc. L'exemple ci-dessous traite le produit scalaire de deux vecteurs selon cette approche.
Un bloc de code correspondant à une itération du schéma structurel est défini.
NJN_DEF_ALWAYS(sp){
njn_ref_t s_prev = njn_new(self, "var", "s_prev", NJN_INPUT);
njn_new(self, "var", "s_next", NJN_OUTPUT);
njn_new(self, "vt_task", "sp",
NJN_ALWAYS(sp), NJN_WHEN(c, e, s_prev));
return NJN_SUCCESS;
}
Les entrées et sorties du bloc correspondent aux opérateurs de la frontière de factorisation. Au niveau hiérarchique supérieur, ils sont associés à des vecteurs par l'intermédiaire d'opérateurs NJN_FORK ou NJN_ITER afin d'établir les règles de développement du schéma répétitif. De façon générale, les entrées du bloc peuvent être associées à des sommets de type F, D ou I et les sorties à des sommets de type J ou I.
NJN_DEF_COMPONENT(sp){
njn_ref_t c = njn_new(self, "vector", "c", NJN_ELEMTYPE("var"),
NJN_INPUT);
njn_ref_t e = njn_new(self, "vector", "e", NJN_ELEMTYPE("var"),
NJN_INPUT);
njn_ref_t s = njn_new(self, "var", "s", NJN_OUTPUT);
njn_new(self, "generate", "v", NJN_BLOCK(v),
NJN_FORK("c", c), NJN_FORK("e", e),
NJN_ITER("s_prev", "s_next", dohc_float(0.0), s));
return NJN_SUCCESS;
}
NJN gèrera les itérations du schéma ainsi défini en fonction des opérations faites sur les vecteurs connectés aux sommets de factorisation.
4 La distribution
Complémentaire de la reconfiguration dynamique, la distribution permet de répondre aux besoins de deux cas de figures radicalement différents : d'une part, le problème de la séparation matérielle entre les entrées/sorties du système (capteurs, actionneurs, etc.) et les moyens de gestion ou de calcul et, d'autre part, le problème de la répartition de la charge de calcul sur plusieurs unités de traitement.
124 - Chapitre 5
Les caractéristiques de la distribution liées à la première situation sont prévisibles dès la spécification du système. Tel capteur se trouve associé à un premier calculateur, tel autre à un second, etc. de même pour les actionneurs. On peut alors prévoir pour ces dispositifs une distribution plus ou moins gravée dans l'architecture de l'application en procédant comme le font par exemple RTMAPS ou ou Simulink : positionner des opérateurs destinés à établir la communication entre deux dispositifs distants.
Concernant le problème de la répartition de charge, les choses sont un peu différentes. La structure de la distribution n'est pas liée à l'application elle-même mais à une question d'optimisation dynamique. Outre les risques de dépassement de latence, l'application a le même comportement quelque soit la structure de la distribution. Il est donc préférable de s'orienter vers une distribution plus transparente.
Les concepts mis en œuvre pour satisfaire ces deux visions de la distribution ne sont pas très complexes. Mais il est important de garder à l’esprit le service rendu par les objets décrits ici, lorsque l'on souhaite développer des applications distribuées.
Dans cette partie, on aborde successivement la réponse d'NJN aux deux situations décrites plus haut. Encore une fois, c'est le point de vue du développeur d'application qui est adopté ici.