Traduction de Tâche Ada dans les ECATNets

Nous donnons ici une vue sur notre traduction systématique des tâches Ada dans les ECATNets.

Types. Ils sont traduits aux sortes dans les ECATNets.

Tâche. Dans Ada, une tâche est définie comme un type spécial : type actif. Le type ‘tâche’ est représenté par un terme algébrique et son aspect dynamique est représenté dans ce cas par un ECATNet. Nous choisissons un n-uplet contenant le terme algébrique ‘tâche’ et les termes algébriques ‘variables locales’ de cette tâche.

Instructions.

Instruction. Elle est représentée par une transition.

Instruction d’Affectation. Il est possible de représenter n’importe quelle affectation générale à l’aide d’un ECATNet. La transition dans la figure 1 est la translation de l’affectation x:= exp.

Instruction Conditionnelle. Cette instruction est représentée par deux transitions en conflit. Une transition pour orienter le contrôle vers la partie du code quand la condition est vraie et l'autre pour l'orienter vers la partie du code si la condition est fausse. La condition est une expression booléenne qui peut être décrite par la condition de la transition. La figure 2 montre un ECATNet résultant de la traduction de l’instruction if c then I1 else I2 endif.

Boucle (Loop). À la fin du code de la boucle, nous ajoutons un arc vers le début de ce code.

Appel de Procédure. Nous représentons des procédures de type ‘void’ par des termes. Quand une procédure (ou tâche) appelle une autre, la procédure appelante ne peut pas passer ses variables locales à l’appelée. Les variables de chaque procédure (ou tâche) sont locales et ne peuvent pas être modifiées par une autre procédure (ou tâche). La transition représentant l'appel d'une procédure doit mettre au début de la procédure appelée le n-uplet composé de son nom, ses paramètres et ses variables locales et mettre dans une autre place le n-uplet représentant la procédure appelante. Pour faire cela, nous exprimons l'état d'attente de cette procédure. S'il y a un appel par valeur, il est nécessaire de mettre les noms des variables utilisées dans l’appel dans la position du paramètre correspondant dans le n-uplet au moment de l'appel. Si P appelle une procédure P1(in v1: t1, out v2,: t2,…) par P1(x,…), nous obtenons l'ECATNet de la figure 3.

assig_stmt <x>

<exp>

Figure 1. Représentation d'une instruction d'affectation dans Ada par un ECATNet

c not c

code de I2 code de I1

Figure 2. Représentation de l’instruction if-then-else dans Ada par un ECATNet

Tâches et Communications entre Tâches.

Figure 3. Représentation d'un appel de procédure dans Ada par un ECATNet

Return_P1 (P,x,y,…) (P,x,y,…) Call_P1 (P1,x,v2,…) code de P1 (P,x,v2,…) (P,x,y,…) (P1,v1,v2,…) ETaskFilter E.TaskSelect (t1,v1) (t2,v2) (tn,vn) (ti,vi) (ti,vi) Accept E (ti,vi) (ti,vi) head(q) q q remove(q) q q add(q,(ti,vi)) RV

Entrée (Entry). Pour une entrée de tâche, nous associons deux places pour contrôler la file d'attente qui contient les tâches en attente qui ont appelé cette entrée. Une place sert à contrôler l'ordre d'arrivée des tâches et elle doit avoir la taille maximale de supporter une seule tâche. Celle-ci doit être transférée à la file d'attente de l'entrée qui est dans l'autre place. Pour cela, nous faisons appel à la définition en termes de spécification algébrique de la file d'attente :

• q est une variable de type Queue.

• head(q) est la fonction qui retourne la tâche en tête de q. • add(q, (ti, vi)) est la fonction qui ajoute la tâche (ti, vi) à q. • remove(q) est la fonction qui retire la première tâche de q.

• l’attribut count correspond à la fonction qui retourne la taille de la file d’attente. Nous pouvons définir sa structure de la même manière: count(q).

Pour une entrée avec une garde, nous traduisons cette garde à une condition de la transition correspondante. La figure 4 est un ECATNet qui traduit une entrée E d’une tâche t. Les places TaskAskE et AcE doivent avoir une capacité maximale d’un seul jeton. Nous avons une condition supplémentaire isempty(q) = false pour la transition E.TaskSelect.

Types Protégés. Pour la traduction d'un type protégé, nous créons une place contenant ses variables. Ces dernières attendent pour être traités par une fonction, une procédure ou une entrée. Pour chacune de trois actions, nous associons une transition en conflit avec les autres transitions. Pour chaque fonction, procédure ou entrée, il est nécessaire d’avoir une place contenant les tâches demandant son exécution.

L'exécution de la transition qui représente le début du code de fonction par une tâche doit retirer la tâche exécutrice, et elle doit examiner la présence des variables du type dans leurs places. Elle assure qu'aucune procédure ou une entrée n'est en évolution. La transition ne retire pas de telles variables pour permettre à une autre tâche l’exécution du code de la fonction. La transition permettant d’entrer dans le code de la fonction, doit mettre la tâche exécutrice dans une place particulière qui sert à savoir quelles sont les tâches en cours d’exécution de cette fonction. L'exécution de la transition représentant l'entrée vers le code d'une procédure doit retirer les variables du type, la tâche exécutrice et elle doit examiner s'il n'y a aucune fonction en cours d'exécution. En ce qui concerne une procédure, l'entrée gère une file d'attente et probablement une garde. La transition qui permet d’atteindre l'exécution du code d'une fonction, d'une procédure ou d'une entrée doit insérer les variables du type privé, les paramètres de la fonction, en outre, de la

task_run_fct task_run_proc (ti,vi) (ti,vi) (ti,vi) (ti,vi) (ti,vi) protected_type ^{task_wait_proc} task_wait_fct (nt,v) (nt,v) (ti,vi) code de fct code de proc (ti,vi) (ti,vi)

Figure 5. Représentation d’une fonction et d’une procédure de type protégé dans Ada par un ECATNet

procédure ou de l'entrée respectivement et l’identité de la tâche exécutrice. D'autre part, il est nécessaire de faire la correspondance entre les paramètres de tâche et ceux de la fonction, de la procédure ou de l'entrée. Les figures 5 et 6 montrent un ECATNet représentant l'exécution d'une fonction, d'une procédure ou d'une entrée par une tâche. La séparation est faite pour contrôler la complexité du diagramme obtenu.