Étude de l’algorithme - La sémantique du formalisme STPN (sans blocage)

2.2 La sémantique du formalisme STPN (sans blocage)

3.2.3 Étude de l’algorithme

Trois questions se posent pour la vérification d’un algorithme : sa terminaison (i.e, il ne boucle pas à l’infini), sa correction (i.e. il donne le bon résultat) et sa complexité algorithmique (i.e, pour une donnée d’entrée combien d’opé- rations sont nécessaires pour finir). En considérant ces trois questions, nous allons analyser notre algorithme.

Nous considérons dans ce qui va suivre la génération d’un nouvel état comme une opération atomique, c.à.d que les opérations élémentaires réalisées pour la génération d’un état sont agrégées (calcul de l’ensemble des transitions sensibilisées, calcul des ensembles de transitions tirables et les structures conditionnelles (if-then-else), gestion des conflits, etc). Ces opérations élémen- taires sont vérifiés séparément (cf. chapitre6). Une génération d’état est donc considérée comme une opération correcte. Le but de cette preuve est de montrer que notre algorithme énumère tout les états du SBG pour n’importe quel STPN d’entrée.

Terminaison

L’algorithme a comme entrée un état e. A partir de cet état, il calcule les états successeurs en se basant sur la structure du STPN, la sémantique

du SBG (E, e0, ։) et la répartition des transitions sensibilisées par rapport

aux ensembles des transitions tirables ETT. Une récursion de l’algorithme est

alors lancée pour chaque nouvel état successeur e′_{, si cet état n’existe pas déjà}

(e′ _{∈ E). La récursion s’arrête s’il n’y a aucune transition sensibilisée dans}_/

l’état d’entrée, ou si tous les états successeurs générés existent déjà dans le SBG.

La terminaison de l’algorithme dépend également du nombre de successeurs générés à partir de l’état d’entrée. Or le nombre de successeurs est dépendant du nombre de transitions sensibilisées dans cet état, et des ensembles ETT dans

lesquelles ils se trouvent. Nous allons étudier en particulier les cas conduisant à utiliser la fonction PowerSet. Comme l’ensemble de transitions sensibilisées à chaque état e est un ensemble fini, la fonction PowerSet retourne un nombre nécessairement fini d’ensembles de transitions. Par conséquent, les variables i des boucles for utilisées dans l’algorithme sont comprises entre 1 et le cardinal du PowerSet(). Ainsi, ces boucles "for" se terminent, au sens d’un nombre fini d’itérations.

Dans le cas où le STPN n’est pas borné, l’algorithme boucle certes à l’infini, mais il suﬃt juste de fixer une condition de terminaison pour limiter le marquage "atteint" dans les places (i.e. imposer une borne k de sortie) ; c.à.d, si un nombre k (k ∈ N) de jetons est présent dans un marquage m, alors l’algorithme s’arrête. Donc, nous considérons que les données d’entrée (le modèle STPN) sont bornées (nombre de transitions, marquage, etc).

Correction

Nous pouvons démontrer, par récurrence, que notre algorithme produit un résultat correct. Une preuve par récurrence consiste à montrer que l’algorithme donne le bon résultat dans deux étapes :

1. Initialisation P (0) : pour le cas de base, s’assurer que le résultat est correct ;

2. Transmission P (n+1) : supposer que le résultat est correct pour n itéra- tions de l’algorithme P (n) et prouver qu’il reste correct pour l’itération n + 1.

P (n) : Supposons que le SBG généré après n itérations est correct. P (0) : A partir de l’état initial e0, si aucune transition n’est sensibilisée

alors l’algorithme retourne un SBG qui a seulement e0comme état. Dans

le cas inverse (l’ensemble de transitions sensibilisées n’est pas vide), il y a toujours un nombre fini de transitions sensibilisées d’entrée, puisque le modèle conçu comporte toujours un nombre fini de transitions. Les diﬀérents types d’intervalles temporelles possibles des transitions sont : [1, 1], [a, a], a $= 1, [1, b], [1, +∞[ et [a, b], a $= 1. Comme le montre la table 3.1, chacun de ces cas est assimilés à un des ensembles ETT et est traité par un des cas de l’algorithme. La grille de lecture de la

table 3.1 est la suivante : les colonnes de la première ligne correspond aux diﬀérents types de transitions possibles, et la seconde ligne sont les ensembles de transitions tirables correspondant. Une ligne correspond donc à une combinaison possible, avec O (Oui, l’ensemble n’est pas vide) et N (Non : l’ensemble est vide). La première colonne indique par quel cas l’algorithme traite cette combinaison. Selon la combinaison activée par les transitions sensibilisées dans un état donné, l’algorithme détermine, en respectant la sémantique du SBG, les tirs possibles de ces transitions. Les marquages et les intervalles résiduels de tirs des nouveaux états sont calculés comme défini dans la sémantique du SBG.

Table 3.1 – Les diﬀérentes combinaisons de transitions traitées par l’algo-

rithme

[1, 1] [1, b] [1, +∞[ [a, a] [a, b]

NFT PFT LFT IFT

cas 1 O N O/N O/N

cas 2 O O O/N O/N

cas 3 N O O/N O/N

cas 4 N N O O

cas 5 N N O N

cas 6 N N N O

Arrêt d’algorithme N N N N

P (n + 1) : Quel que soit le nombre d’itérations n, à un état e, s’il existe une (plusieurs) transition(s) sensibilisée(s), alors toutes les transitions sen- sibilisées dans cet état sont classées forcément dans l’un des ensembles de transitions tirables. L’algorithme traite toutes les combinaisons pos-

sibles de ces ensembles (cf. table3.1) et conduit vers les états successeurs

e′. Pour chaque état successeur e′_{, s’il n’existe pas de transition sensibi-}

lisée ou si tous les états e′ _{existent déjà dans le SBG alors l’algorithme}

s’arrête et retourne le SBG résultant. Sinon, une nouvelle récursion de l’algorithme avec les nouveaux états est faite. Et ainsi de suite.

Ainsi, l’algorithme traite toutes les combinaisons possibles d’ETT pour chaque état traité, et génère un successeur pour chaque évolution d’états possibles. Puis une récursion est lancée sur chacun de ces successeurs. L’algorithme énumère donc tous les états du SBG pour n’importe quel modèle STPN d’en-

trée. Par supposition (même si cela a été vérifié lors de la validation des algo- rithmes, cf. chapitre 6), la génération d’un nouvel état est toujours correcte. Par conséquent, cette preuve permet d’assurer que notre algorithme donne toujours un bon SBG pour n’importe quel STPN d’entrée.

Complexité

En général, la complexité de la génération des graphes de comportement pour les RdP classiques dépend directement du parallélisme entre les transitions du modèle (i.e., parallélisme traité par entrelacement). Dans notre cas, cela n’est plus vrai, i.e. toutes les transitions en parallèle sont tirées simultané- ment par un seul changement d’états. Par contre, la complexité de notre algorithme est liée à l’énumération discrète du temps et les tirs potentiels des transitions (parallélisme eﬀectif). Le calcul de la complexité de notre algorithme est lié à la configuration des intervalles temporels des transitions sensibilisées (les combinaisons ETT). Ainsi, c’est impossible de calculer la complexité exacte ; en l’occurrence nous pouvons donner le pire cas.

La définition classique de la complexité algorithmique est le nombre d’opé- rations eﬀectuées par l’algorithme afin de rendre le résultat attendu. Le nombre d’opérations est exprimé en fonction de la taille des données d’entrées. Dans le cas de notre algorithme, les opérations sont les conditions, des boucles "for", la boucle de récursion de l’algorithme et la génération des nouveaux états. Comme nous l’avons expliqué, nous considérons ici la génération d’un nou-

vel état comme une opération atomique "constante". La table 3.2 indique le

nombre d’états successeurs générés pour chaque cas de l’algorithme. Les lignes

de la table 3.2 sont les cas présents dans l’algorithme et les colonnes sont les

ensembles de transitions tirables. Les notations O et N correspondent respec- tivement aux cas où les ensembles issus de ETT sont non vides ou vides. La

dernière colonne de la table 3.2 représente le nombre d’états successeurs gé-

nérés. Il faut préciser que pour chaque itération de l’algorithme, un seul cas (combinaison de ETT) est possible.

Dans la majorité des cas (les combinaisons ETT) d’algorithme, un seul état est généré par itération. Par contre, le nombre d’états générés peut varier entre

1 et m (m ∈ N+_{) dès qu’il y a présence de transitions probablement tirables.}

Comme nous l’avons préalablement expliqué, si P F T $= ∅ ou IF T $= ∅ (cas 4.3), une boucle "for" est utilisée pour énumérer les tirs probables, avec comme

borne maximale d’itération la cardinalité de l’ensemble P owerSet(P F T ) (resp. P owerSet(IF T )). Dès lors, dans cette situation le nombre d’états générés m est égal à 2|P F T | _{(resp. 2}|IF T |_{), ce qui correspond à la complexité de calcul de}

la fonction P owerSet. Ainsi, la pire complexité de l’algorithme, si on suppose que l’algorithme génère chaque pour itération 2|P F T | _{états, alors sera pour n}

itérations, est n ∗ 2|P F T | _{(resp. n ∗ 2}|IF T |_).

Table 3.2 – Nombre d’états générés pour une itération de l’algorithme, à partir d’un état donné

Cas /ETT NFT PFT LFT IFT Nombre d’états générés (m) cas 1 O N N N 1

La pire complexité estimée de l’algorithme est exponentielle. Elle dépend directement du nombre de transitions potentiellement tirées et du parallélisme entre de telles transitions (dont l’intervalle est, rappelons-le, infini). Il s’agit bien évidemment d’une limitation classique des méthodes de construction de graphe, induite ou accrue par un fort parallélisme. Néanmoins les systèmes que nous considérons, à savoir les dispositifs implantables ou plus généralement pe- tits systèmes embarqués, sont nécessairement contraints (limités en ressources) et le parallélisme eﬀectif (i.e., à l’instant t) reste limité en réalité. Si on veut traiter cette complexité théorique, notre méthode pourrait tout de même être améliorée en s’inspirant des approches symboliques [69] pour la limitation liée

à l’énumération, et des approches par ordre partiel [45, 16] pour l’élimination

des entrelacements liés aux tirs probables.

Dans le document Validation formelle des systèmes numériques critiques : génération de l'espace d'états de réseaux de Petri exécutés en synchrone (Page 98-102)