Fonctions de diffusion des Contraintes

Une fois le graphe structuré par les différents Blocs, nous pouvons diffuser les Contraintes des Atomes à notre Composition. Ce processus est réalisé à l’aide de fonctions de diffusion qui dépendent de la nature du Bloc. Ces fonctions vont nous permettre de déterminer une expression littérale des différentes propri´et´es des Contraintes temporelles. Celles-ci seront ensuite valuées de manière spécifique pour chaque cible d’implémentation.

Considérons tout d’abord un Bloc Bs. Il est constitué de n Blocs. Parmi eux, les Sous-Blocs

1 à i sont eux-mêmes des Blocs, le j-ième Bloc étant noté Bj tandis que les Sous-Blocs i+1 à n

sont des Atomes, le k-ième étant noté Atk. Ce Bloc est également connecté à m Besoins sur les-

quels portent des Contraintes temporelles de nature P ´eriodique appartenant à d’autres Blocs (faisant potentiellement partie du même graphe ou d’un graphe temporellement indépendant). Le o-ième de ces Besoins est noté neo. Nous devons tout d’abord calculer tcompmax(Bs).

S’il s’agit d’un Bloc série, cela est fait à l’aide de la fonction (6.1).

tcompmax(Bs) = i X j=1 tcompmax(Bj) + n X k=i+1

tcompmax(Atk) + tcomm(Bs) (6.1)

Dans un Bloc série où chaque Sous-Bloc est calculé l’un à la suite de l’autre, une estimation du temps de calcul total dans le pire cas est égal à la somme des temps de calcul (pire cas) de chaque Sous-Bloc pris individuellement auquel est ajouté un terme, tcomm, qui réifie la somme

totale des temps de transition entre les différentes entités contenues dans le Bloc. Ce terme contient aussi bien les temps de transfert des données d’un Atome à un autre que les délais induits par l’architecture logicielle (commutation de tâches temps-réel, ordonnancement par exemple).

S’il s’agit d’un Bloc parallèle, cela est fait à l’aide de la fonction (6.2).

tcompmax(Bs) = f (tcompmax(B1), ..., tcompmax(Bi), tcompmax(Ati+1), ..., tcompmax(Atn))

On retrouve ici le terme tcomm qui sert toujours à prendre en compte les temps de transition

entre le calcul de chaque entité. Néanmoins contrairement au cas des Blocs série, la relation entre le temps de calcul total et les temps de calcul individuels est matérialisée par une fonction f qui ne peut pas être définie à ce stade de l’approche. En effet, cette fonction dépend de la manière dont sont gérés les parallélismes dans l’architecture logicielle et dépend de fait de la cible d’implémentation logicielle. Or, à ce stade, comme expliqué au début du chapitre, le processus est encore indépendant de la cible d’implémentation. La définition de f ne sera donc déterminée que lors de l’étape suivante, la valuation des propri´et´es des Contraintes. Nous pouvons néanmoins ici préciser les différentes formes que peut prendre f. Deux définitions principales se dégagent. La première suppose que le parallélisme n’est pas utilisé ou n’est pas utilisable (monoprocesseur), c’est-à-dire que tous les calculs s’effectuent les uns à la suite des autres. La fonction est dans ce cas identique à celle utilisée dans le cas d’un Bloc série (équation (6.1). La seconde suppose que les n entités sont toutes exécutées en parallèle (multiprocesseur). Dans ce cas, on a :

f (tcompmax(B1), ..., tcompmax(Bi), tcompmax(Ati+1), ..., tcompmax(Atn)) =

max(tcompmax(B1), ..., tcompmax(Bi), tcompmax(Ati+1), ..., tcompmax(Atn)) (6.3)

En effet, si le calcul de toutes les entités est effectué en parallèle alors le temps total dépend du temps d’exécution le plus long parmi les entités. Bien entendu, les deux définitions données ici pour f ne sont que des cas "extrêmes". Toute combinaison de ces deux fonctions est bien entendu possible en fonction à la fois de la volonté du concepteur et des possibilités du ou des calculateurs (nombre maximal de calculs parallélisables notamment). Il faut enfin noter que, dans notre cas, le Middleware que nous allons utiliser (cf. Chapitre 7) ne permet que d’effectuer les calculs sur un unique processeur. De fait, nous n’utiliserons dans nos travaux que la première fonction (celle pour les entités placées en série).

De là il est possible de déterminer la valeur de Texe(Bs). Cela est fait à l’aide de la fonction

(6.4).

Texe(Bs) = [tcompmax(Bs) ∞]

i \ j=1 Texe(Bj) n \ k=i+1 Tphy(Atk) m \ o=1 TN eed(neo) (6.4)

Le premier terme réifie l’impact de la durée des calculs sur l’ensemble des périodes ad- missibles. En effet, nous ne pouvons pas réitérer nos calculs plus rapidement que le temps mis pour les effectuer. Néanmoins, étant donné que nous considérons pour cela le pire cas des

6.3. Diffusion des Contraintes

temps de calcul, notre approche est clairement très conservative. En effet, individuellement, chaque Atome n’a qu’une certaine probabilité de s’exécuter à son pire cas et donc il est peu probable que la Composition de ceux-ci s’exécute à chaque cycle avec le pire cas au niveau temporel. En outre, bien entendu suivant l’amplitude et l’occurrence (i.e. nombre de cycles en dépassement sur une fenêtre glissante) des dépassements, un système temps-réel peut, grâce à l’ordonnanceur, parvenir à gérer des dépassements et à retrouver sa régularité d’exécution.

Ensuite, la période d’exécution est obtenue par calcul de l’intersection des périodes d’exé- cution possibles des Sous-Blocs qu’il contient et de leur intersection avec les périodes de rafraichissement désirées pour les Besoins ayant des Contraintes de nature P ´eriodique.

Exemple 6.4:

Appliquons ces formules à l’Exemple 6.3 (Figure 6.11).

On value ainsi les propri´et´es du Bloc série englobant notre Graphe d’Association de Connaissances, S4, comme :

tcompmax(S4) = tcompmax(S3) + tcompmax(P2) + tcompmax(P1) + tcomm(S4) (6.5)

Texe(S4) = [tcompmax(S4) ∞] ∩ Texe(S3) ∩ Texe(P2) ∩ Texe(P1) (6.6)

Ici, tcomm(S4) englobe les durées de transition entre les Blocs P1, P2 et S3. C’est-à-dire la

durée d’échange au niveau des Liens entre les Instances F T oRob et F T 0y, F T oRob et F T 0z, LocT oRob et F T 0y, LocT oRob et F T 0z, LocT oRob et DyM od, F T 0y et DyM od et enfin F T 0z et DyM od. Ici, vu que nous n’avons qu’un seul Graphe d’Association de Connaissances il n’y a pas de Besoin de nature P ´eriodique à utiliser pour le calcul de Texe(S4).

Les propri´et´es de S3 sont obtenues par les équations suivantes car il s’agit d’un Bloc série :

tcompmax(S3) = tcompmax(DyM od) + tcompmax(Act) + tcomm(S3) (6.7)

Texe(S3) = [tcompmax(S3) ∞] ∩ Tphy(DyM od) ∩ Tphy(Act) (6.8)

tcomm(S4) comprend la durée de transition entre les Instances DyM od et Act.

Les propri´et´es de P2 sont obtenues par les équations suivantes car il s’agit d’un Bloc

parallèle :

tcompmax(P2) = fP2(tcompmax(F T 0y), tcompmax(F T 0z)) + tcomm(P2) (6.9)

Texe(P2) = [tcompmax(P2) ∞] ∩ Tphy(F T 0y) ∩ Tphy(F T 0z)

tcomm(P2) intègre les temps de transition entre l’exécution des Instances F T 0y et F T 0z.

En outre, celles-ci étant connectées à des Besoins de nature P ´eriodique de l’Instance DyMod, nous voyons apparaître l’impact de ceux-ci dans le calcul de Texe(P2).

A titre d’illustration, dans notre cas applicatif (i.e. pas d’utilisation du parallélisme) et en prenant un peu d’avance sur l’étape suivante, la fonction de diffusion (6.9) devient :

tcompmax(P2) = tcompmax(F T 0y) + tcompmax(F T 0z) + tcomm(P2) (6.11)

Les propri´et´es de P1 sont obtenues par les équations suivantes car il s’agit d’un Bloc

parallèle :

tcompmax(P1) = fP1(tcompmax(S1), tcompmax(S2)) + tcomm(P1) (6.12)

Texe(P1) = [tcompmax(P1) ∞] ∩ Texe(S1) ∩ Texe(S2) (6.13)

Avec :

tcompmax(S1) = tcompmax(P S) + tcompmax(SonT oRob.CylT oCart) + tcompmax(SonT oRob.F S)

+ tcompmax(SonT oRob.CartT oCyl) + tcompmax(RobT oDV Z.CylT oCart)

+ tcompmax(RobT oDV Z.F S) + tcompmax(RobT oDV Z.CartT oCyl) + tcompmax(DV Z)

+ tcompmax(RF C) + tcompmax(F T oRob) + tcomm(S1) (6.14)

Texe(S1) = [tcompmax(S1) ∞]∩Tphy(P S)∩Tphy(SonT oRob.CylT oCart)∩Tphy(SonT oRob.F S)

∩ Tphy(SonT oRob.CartT oCyl) ∩ Tphy(RobT oDV Z.CylT oCart) ∩ Tphy(RobT oDV Z.F S)

∩ Tphy(RobT oDV Z.CartT oCyl) ∩ Tphy(DV Z) ∩ Tphy(RF C) ∩ Tphy(F T oRob) (6.15)

tcompmax(S2) = tcompmax(LD) + tcompmax(LocT oRob) + tcomm(S2) (6.16)

Texe(S2) = [tcompmax(S2) ∞] ∩ Tphy(LD) ∩ Tphy(LocT oRob) (6.17)

Puisque S1 et S2 sont des Blocs série. Ici, tcomm(P1) comprend la durée de transition entre

l’exécution des Blocs S1 et S2 et au sein de ceux-ci, tcomm(S1) et tcomm(S2) représentent les