Vérification de systèmes matériels avec les DDD Systèmes spécifiés à un haut niveau d’abstraction DDD : Structure de données exploitant le partage et la hiérarchie Emmanuelle Encrenaz-Tiphène Maître de Conférences à l’Université Paris VI – LIP6 En délégation CNRS au Laboratoire Spécification et Vérification (LSV) ENS-Cachan En collaboration avec Vincent Beaudenon

Préambule – Hardware / Software Codesign Application : réseau de tâches communicantes liens privés avec bufferisation (réseaux de Khan) particularisation : données entières – buffers bornés – sélection Exploration architecturale (différentes possibilités d’implantation des tâches) Implantation matérielle (synthèse de haut niveau / synthèse des communications) Chaîne de conception Disydent [Pétrot Augé et al, 03]

Vérification fonctionnelle de systèmes matériels Simulations presque uniquement Equivalence-Checking pour des blocs combinatoires / RTL Symbolic Model-Checking pour des petits blocs (10 KG) Méthodes « semi-formelles » prennent le pas sur SMC LTL sur séquences bornées  moniteurs incorporés dans la simulation CTL à profondeur bornée  déroulement explicite de l’arbre d’exécution Démonstrations assistées (architectures spécifiques : cœurs de processeurs / traitement du signal)

Notre objectif Construire un Model-Checker Symbolique pour des systèmes décrits sous forme de graphe de tâches. Représentation symbolique d’ensembles d’états du système + opérations ensemblistes (, , ) Données entières / structurées Canaux de taille variable Opérateurs Post et Pré sur la représentation symbolique de l’ensemble des états, associés à la sémantique des actions du graphe de tâches.

Plan de l’exposé Modélisation de systèmes dans un sous-ensemble de ProMeLa Représentation symbolique : Structure de donnée DDD Représentation des ensembles d’états Opérations ensemblistes Homomorphismes Homomorphismes pour instructions ProMeLa Introduction de la hiérarchie Application à la vérification de propriétés CTL Exemples classiques Réseau VCI-SPIN Conclusion

La plate-forme de vérification ProMeLa-SPIN [G. Holzmann 97] Langage ProMeLa : description d’applications concurrentes, dynamiques, asynchrones, communication par buffers bornés et variables partagées Vérification de propriétés de sûreté et de vivacité par exploration du graphe des états accessibles Représentation explicite des états Réduction de l’espace à analyser (techniques d’ordre partiel / compactage) Applicable pour des systèmes "séquentiels" comportant 106 à 107 états

Un sous-ensemble de ProMeLa Variables globales Types scalaires (basés sur entier) / Type produit Tableaux Canaux (bornés) Processus concurrents Variables locales Instructions gardées (affectations, lecture / écriture) Choix indéterministe Répétition indéterministe Pas d’instanciation dynamique de processus (run est exclu) Les processus n’ont pas de paramètres

Exemple de description proctype proc_port_in0_0() { MOT mess; bit reserve; bit current_clock=0; mtype sortie_down; bit jeton = 1; do :: (clock == current_clock) -> current_clock = !current_clock; x0_d0_spin_data_in?mess-> if :: (((mess.addest >> level_num0_0) & 3) == level_id0_0) -> /* Traitement des ports DOWN. */ sortie_down = (mess.addest >> (level_num0_0-1)) & 1; if :: (sortie_down == 0) -> poss_out0_0?jeton; do :: x0_d0_spin_data_out!mess; if :: mess.tag == FIN -> atomic{poss_out0_0!jeton; goto SUITE_DOWN;} :: else -> x0_d0_spin_data_in?mess; fi; … } variables locales lecture dans un canal affectation garde écriture dans un canal

Représentation symbolique d’états Diagrammes de Décision de Données (DDD) Structure de donnée pour représenter les ensembles d’états. (LIP6 / LaBRI ): arbres partagés. projet Clovis [DGA 01] Application aux réseaux de Petri étendus [ATPN 02] [FORTE 04] [FORTE 05] Variables décisionnelles de type fini Représentation des chemins menant à 1 ou T Exploitation du partage des sous-arbres isomorphes Opérations ensemblistes : parcours attelé des 2 DDD (polynômial) Modification « la plus locale possible » : homomorphisme

DDD : Structure Nœuds : variables Arcs : valeur dans les entiers Contrainte: un seul arc d’une étiquette donnée en sortie d’un nœud a b c 1 2 a 1 partage 2 b 2 1 c 1 1 Interprétation : ensemble de mots (affectations) menant au nœud 1 Efficacité : partage

DDD : Normalisation Les chemins invalides ne sont pas représentés Conséquence : domaine des variables inconnu a priori Représentation de l’ensemble vide  nœud terminal 0 a a 1 2 1 normalisation 2 b c b 1 2 2 1 1 partage 1 c 1 c 1 1 1 1 Représentation canonique des DDD (classe d’équivalence)

DDD : Opérations ensemblistes (1) Un DDD est un ensemble de mots : Opérations ensemblistes + * \ Exemple : a a 1 a b c 3 4 6 1 b c 2,3 4 2,6 3,4 1,3 2,4 6 3 2 A * B A B A*B

DDD : Opérations ensemblistes (2) Un DDD est un ensemble de mots : Opération de concaténation . Exemple : . v0 1 v0 A . A . B v1 . v1 1 . B 1

DDD : Homomorphisme Définition :  d, d’ deux DDD bien définis Un homomorphisme est une fonction  telle que :  (0) = 0  (d) +  (d’) =  (d + d’)  1 d d’  1 d d’ réunion réunion

Homomorphismes inductifs Homomorphisme défini localement (0) = 0 (1) = constante (d) = définition locale à la racine de d et ses valuations Exemple : affectation d’une valeur constante var=val e x …. val Si e == var Sinon var=val

Homomorphismes inductifs Affectation v1 = Constante SetCst(var,val) (1) = T (une erreur) e — Id si e == var SetCst(var,val) (e,x) = e — SetCst(var,val) sinon val x

Autres homomorphismes inductifs SetVar (v1,v2) SetVarExpr (var, expr) SelVarCst (var, const) SelExp (expr) …

DDD pour les programmes ProMeLa Un état du programme : variables globales chaque processus en cours d’exécution son compteur ordinal ses variables locales Etat initial = concaténation de toutes les variables dans un ordre figé Instruction ProMeLa = construction de deux homomorphismes Post: calcule les successeurs par l’application d’une instruction Pré : calcule les prédécesseurs potentiels résultants de l’exécution d’une instruction

Homomorphismes inductifs Promela-DDD Affectation gardée exp_g -> x := 5; … Indéterminisme if :: exp_g1 -> (2.) … :: exp_g2 -> (3.) … fi; 4. … Ecriture dans un canal c!x SetCst(pc,2) o SetCst(x,5) o SelExp(pc==1  exp_g) SetCst(pc,2) o SelExp(pc==1  exp_g1) + SetCst(pc,3) o SelExp(pc==1  exp_g2) SetCst(pc,2) o SetVarFifo(c,x) o SelCst(pc==1)

Calcul de l’ensemble des états accessibles New = Init; Reached = ; While New   loop tmp = New Forall process p loop Forall instruction i loop To = Postp,i(tmp); tmp = To + tmp; Endloop New = tmp \ reached Reached = tmp + reached Return Reached

Evaluation de formules CTL Opérateur Pré : Pb : Toutes les opérations ne sont pas inversibles : x = 4; Approche classique (2 à 3 passes) : élargissement à toutes les valeurs possibles, puis restriction aux états accessibles Opérateur ad-hoc en 1 passe Evaluation de "EF p"

Comparaison avec les BDD Opérateurs Postp,i et Prép,i implantés sur la bibliothèque BuDDy [Lind-Nielsen, Reif Andersen CAV 99] Représentation des opérations arithmétiques sur des vecteurs de bits Domaine des variables déterminé a priori (type déclaré) Traitements pour réaliser Postp,i(E) si i décrit x = y Un seul jeu de variable Abstraction de x dans E : E|x Construction de G = (x  y) = (x  y)  ( x  y) Contrainte de E|x par G : E|x  G

Résultats sur exemples classiques (DDD plats) Dichotomie méthode énumérative / méthode symbolique Systèmes fortement séquentiels jusqu’à 106 ou 107 états : SPIN donne de meilleurs résultats. (sliding window, Peterson, Bakery) Systèmes fortement concurrents jusqu’à 1010 états (au delà si très réguliers) : BDD et DDD donnent de meilleurs résultats. (Philosophes, élection sur anneau) BDD vs DDD BDD avec réordonnancement dynamique et DDD statique sont comparables. Lorsqu’un « bon ordre » peut être exploité, les DDD statiques présentent de meilleures performances que BDD ou DDD ordre qcq. Limitations des DDD : ordre / gestion des expressions / longueur des chemins

Introduction de la hiérarchie dans les DDD (1) HDD : Les valuations des arcs sont des DDD c d 1 3 4 5 2 a b i 2 c d 1 2 3 4 5 a b DDD HDD

Introduction de la hiérarchie dans les DDD (2) Les HDD sont des DDD qui bénéficient : Augmentation du partage, Réduction de la longueur des chemins de la racine vers 1. Ajustement des homomorphismes Propagation de l’homomorphisme au nœud suivant au même niveau de la hiérarchie, au nœud racine du DDD de niveau de hiérarchie inférieur Occasionnellement, nécessité d’aplanir localement la hiérarchie

HDD pour Programme ProMeLa … variables globales processus variable scalaire canal compteur ordinal variables locales variable produit Saturation Lors du calcul de l’ensemble des états accessibles, réordonner le franchissement des instructions pour saturer les couches basses du HDD Hiérarchisation de l’état

Résultats sur exemples classiques (HDD) Confirment la tendance observée avec les DDD plats : SPIN reste meilleur sur les systèmes très séquentiels (Sliding window, Peterson, Bakery) HDD + saturation sont bien meilleurs que les BDD ou les DDD plats sur des systèmes très parallèles (jusqu’à 1000 philosophes, jusqu’à 100 électeurs sur l’anneau)

Réseau VCI-SPIN (1) Apparition d’un interblocage SPIN network VCI-SPIN wrappers I3 I4 T3 T4

Réseau VCI-SPIN (2) Evitement de l’interblocage : séparer les requêtes et réponses sur les liens descendants VCI-SPIN wrappers SPIN network I3 I4 T3 T4

Vérification avec SPIN et HDD Modèle ProMeLa Pour chaque routeur : 1 processus par port d’entrée (4) 1 mécanisme d’exclusivité d’accès par port de sortie (4) Pour chaque initiateur : 2 processus (1 émetteur requête / 1 récepteur réponse) Pour chaque cible : 1 processus Messages bufferisés en entrées de chaque port (buffers de taille 1)

Vérification avec SPIN Propriété de vivacité «émetteur 0 pourra toujours émettre un nouveau message » Configuration à 2 routeurs, initiateurs et cibles fixés Synchronisation des processus Taille des messages fixée (1 à 7 paquets) Vivacité, n=6 : propriété vérifiée en 36000 s et 100 MB Accessibilité, n = 6 : construit en 512 s et 9 MB

Vérification avec HDD Propriété de sûreté : Absence d’état puits Configurations à 2 et 4 routeurs, initiateurs et cibles variables Taille des messages variable (de 1 à 7 paquets) Pour la configuration restreinte : Accessibilité, n=6, synchrone, 2 routeurs : 33 s, 139 MB Pour les configurations plus libres : Accessibilité, n=1 à 7, asynchrone, 4 routeurs, config libre : 7881 s et 492 MB ou : 519 s et 1,5 GB

Conclusion Construction d’un model-checker pour des systèmes statiques décrits en ProMeLa DDD : Représentation intéressante pour les systèmes présentant un fort parallélisme Hiérarchie Saturation Analyse complémentaire à l’outil SPIN Certains systèmes sont analysés très rapidement par SPIN et pas de résultats avec HDD, et réciproquement Propriétés de vivacité / de sûreté

Perspectives Amélioration de l’algorithmique sur les HDD Éviter les applatissements locaux Augmenter la prise en compte de la hiérarchie Découpage dichotomique du système Extension à des systèmes dynamiques

Résultats sur exemples classiques (DDD plats) [BET – Majestic 04] Calcul d’accessibilité + une propriété " AG AF but atteint «  Temps de calcul (en s) / Mémoire nécessaire (en MB) Philosophes SPIN BDD DDD DDD-O 15 : 2251/1067 380+1200/96 18 K+-/397 54+5/30 50: -/- -/- -/- 8006/996 Election sur anneau 6 : 262/144 5056+5394/144 34+5/11 37+3/11 10: -/- -/- 4533+-/663 716+-/77

Résultats sur exemples classiques (DDD plats) Sliding window SPIN BDD DDD DDD-O 2 : 0/8 552+221/102 486+142/18 662+206/17 3 : 29/450 65 K +63 K /332 480 K + - /565 480 K + -/475 4 : -/- -/- -/- -/- Exclusion Peterson SPIN BDD DDD 3 : 0/6 17+39 /93 7+4/6 5 : -/- 470 K + - /900 -/- Bakery 4 : 0/5 50+0/94 17+0/9 5 : 1385/6 1231+0/93 379+5/46 6 : -/- -/- 61901+47/455

Résultats sur exemples classiques (HDD) Calcul d’accessibilité uniquement Philosophes DDD DDD-O HDD HDD-sat 15 : 18 K+-/397 54+5/30 25/16 0/2 50: -/- 8006/996 3308/532 1/9 1000: -/- -/- -/- 258/1343 Election sur anneau 6 : 34+5/11 37+3/11 6/4 0/4 10: 4533+-/663 716+-/77 333/61 2/14 20: -/- -/- 9891/771 14/65 100 : -/- -/- -/- 443/1866 Systèmes séquentiels : Amélioration par rapport aux DDD plats mais moins bons que SPIN

DDD : Approximation Contrainte : un seul arc d’une étiquette donnée en sortie d’un nœud Conséquence : des opérations peuvent conduire à des résultats indéterminés Représentation de l’approximation  nœud terminal T a 1 2 DDD bien défini : absence de nœud terminal T Relation « mieux-défini »  : relation d’ordre sur les DDD a T 1 2 1 b 1 1 Bonnes propriétés algébriques des opérations

DDD : Opérations (2) Exemple d’opération faisant apparaître une approximation a c 1 2 3 a c 1 2 3 a c 1 2 T + =

DDD : Homomorphismes Définition :  d, d’ deux DDD bien définis Un homomorphisme est une fonction  telle que :  (0) = 0  (d) +  (d’) =  (d + d’) Exemples d * Id Id \ d Id . d 1 + 2 1 o 2 Cas général :  d, d’ deux DDD  (d) +  (d’)   (d + d’) d  d’   (d)   (d’)

DDD : Homomorphismes inductifs (1) Famille d’homomorphismes i définis localement i (0) = 0 i (T) = T i (1) = ci (une constante) i (d) = définition locale à la racine de d et à ses valuations Exemple SetCst(var, val)(1) = T SetCst(var, val)(e, x) = val e — Id si e = var e — SetCst(var,val) sinon x

DDD : Homomorphismes inductifs (2) a b c 1 2 1 = SetCst(b,2) (a — b — 1 ) + SetCst(b,2) (a — c — 1 ) SetCst(b,2) 2 1 SetCst(b,2) (a — b — 1 ) = a — SetCst(b,2)(b — 1 ) = a — b — Id(1) = a — b — 1 1 2 SetCst(b,2) (a — c — 1 ) = a — SetCst(b,2)(c — 1 ) = a — c — SetCst(b,2)(1) = a — c — T 1 2

DDD : Homomorphismes inductifs (3) Exemple : var1 = var2 SetVar SetVar(var1, var2)(1) = 1 SetVar(var1, var2)(e, x) = Down(var1, var2) si e = var1 e — SetCst(var1, x) si e = var2 e — SetVar(var1, var2) sinon x Down Down(var1, var2)(1) = T Down(var1, var2)(e, x) = var1 — e — Id si e = var2 Up(e, x) o Down(var1, var2) sinon x Up Up(var, val)(1) = T Up(var, val)(e, x) = e — var — Id x val

DDD : Homomorphismes inductifs (4) Exemple d’exécution de SetVar : b = d SetVar(b, d) (a — b — c — d — 1) a — SetVar(b, d) (b — c — d — 1) a — Down(b, d) (c — d — 1) a — Up(c, 3) o Down(b, d) (d — 1) a — Up(c, 3) (b — d — Id(1)) a — Up(c, 3) (b — d — 1) a — b — c — d — 1 1 2 3 4 1 2 3 4 1 3 4 1 4 1 4 4 1 4 4 1 4 3 4

Homomorphismes inductifs Affectation V1 = V2 SetVar(v1,v2) (1) = T (une erreur) Down(v1,v2) si e == v1 SetVar(v1,v2) (e,x) = e — SetCst(v1,x) si e == v2 e — SetVar(v1,v2) sinon Down(v1,v2 ) (1) = T Down (v1,v2) (e,x) = v1 — e — Id si e == v2 Up(e, x) o Down(v1, v2) sinon Up(var, val)(1) = T Up(var, val)(e, x) = e — var — Id