Guides pratiques › Vérifier un modèle

Guides pratiques

Vérification : preuves formelles, tests, fautes et logs

archec vérifie que le modèle est juste, et que le système réel se comporte comme le dit le modèle. Il prouve des propriétés des machines à états et des contrats entre parts. Il trouve les exigences incompatibles entre elles. Il exécute des tests avec injection de fautes, mesure ce qu'ils couvrent et confronte les logs du système réel au modèle.

Une première vérification#

Cette lampe a un état dans lequel on n'entre jamais :

message GO "Go" { on: bool }

component Lamp "Lamp" {
  in cmd: data receives GO
  states {
    state Off "Off"
    state On "On"
    state Broken "Broken"
    Off -> On on GO
    On -> Off on GO
  }
}

system Room "Room" {
  part lamp: Lamp
}
Diagramme : Room
Ce qu’archec dessine depuis ce code : Room
Essayer
archec check main.arche
main.arche:8:11 warning State 'Broken' cannot be reached from 'Off' [unreachable-state]
  |     state Broken "Broken"
  |           ^^^^^^
✓ no errors, 1 warning(s)

archec check fait ces vérifications à chaque fois, sans rien à installer. Les sections suivantes présentent les autres vérifications, des plus simples à celles qui demandent un log ou un outil externe.

Vérifications formelles : machines à états et contrats#

Machines à états#

Le linter lit chaque machine à états comme un graphe d'états et de transitions. Une définition qui en étend une autre (extends) reçoit aussi les états et les transitions de celle qu'elle étend, comme dans Arche.

code ce qu'il trouve
unreachable-state Un état qu'aucun chemin n'atteint depuis l'état initial. Entrer dans un état composite démarre dans son enfant pseudo initial, sinon dans son premier enfant (un par region). Une transition qui ne se déclenche jamais ne mène nulle part. goto("X") dans le code atteint X.
deadlock-state Un état atteignable sans aucune sortie, ni depuis lui-même ni depuis un état qui l'englobe, et qui n'est pas pseudo final. C'est un avertissement quand la machine a un état final. C'est une suggestion quand elle n'en a pas, car un défaut verrouillé dont seul un reset fait sortir est souvent voulu. Un état dans lequel tombent tous les états (* -> Fault) est un état sûr. Un composant dont le code appelle goto(…) n'est pas vérifié.
dead-transition Un déclencheur qui est un message qu'aucun port d'entrée du composant ne reçoit, ou une garde qui vaut false. Les messages reçus par un port viennent de receives, de ses handlers et des messages de ses interfaces. Un port qui n'en nomme aucun accepte tout.
shadowed-transition Une transition toujours devancée par une transition antérieure : même état, même déclencheur, et l'antérieure n'a pas de garde.
nondeterministic (suggestion) Deux transitions gardées depuis un même état, sur un même déclencheur, dont les gardes peuvent être vraies en même temps. Sont considérées comme exclusives : else, g et not g, des valeurs distinctes et des intervalles disjoints (x < 0 et x >= 0).

archec ne lit une garde que si c'est une simple comparaison. Une garde écrite en toutes lettres est ignorée.

Contrats#

Un contract dit deux choses d'un composant :

  • ce qu'il suppose de ce qu'il reçoit ;
  • ce qu'il garantit sur ce qu'il envoie.

Sur chaque lien, archec vérifie que la garantie d'un côté satisfait l'hypothèse de l'autre. Ici, la pédale peut envoyer jusqu'à 1500 N, mais le calculateur de freinage attend au plus 1000 N :

message BRAKE_CMD "Brake command" { force: float32 unit N }
message BRAKE_STATUS "Brake status" { applied: bool }

component Pedal "Pedal" {
  out cmd:   data sends BRAKE_CMD
  in status: data receives BRAKE_STATUS
  contract {
    guarantee cmd.force in 0..1500N
  }
}

component BrakeEcu "Brake ECU" {
  in cmd:     data receives BRAKE_CMD
  out status: data sends BRAKE_STATUS
  contract {
    assume cmd.force in 0..1000N
    guarantee status.applied within 20ms after cmd
  }
}

system Car "Car" {
  part pedal:  Pedal
  part brakes: BrakeEcu
  pedal.cmd -> brakes.cmd
  brakes.status -> pedal.status
}
Diagramme : Car
Ce qu’archec dessine depuis ce code : Car
Essayer
archec check main.arche
main.arche:24:3 warning brakes.cmd assumes "cmd.force in 0..1000N", but pedal.cmd guarantees "cmd.force in 0..1500N" … (archec explain contract-unmet) [contract-unmet]
  |   pedal.cmd -> brakes.cmd
  |   ^^^^^^^^^^^^^^^^^^^^^^^
✓ no errors, 1 warning(s)

Comment écrire une clause :

  • Une clause nomme un champ du message d'un port (cmd.force, ou cmd.BRAKE_CMD.force), ou une variable.
  • Elle le compare avec in lo..hi, ==, !=, <, <=, >, >=. Elle peut aussi être nue : status.applied, not fault.
  • Les clauses se combinent avec and.
  • Une clause peut commencer par always ou eventually, et finir par within 20ms, ou within 20ms after port.
  • Une interface ou un type de port peut aussi porter un contrat. Ses clauses nomment le message ou le champ. Elles s'appliquent à chaque port qui relève de cette interface ou de ce type.

Sur chaque lien a.p -> b.q, ce que a garantit sur p doit impliquer ce que b suppose sur q :

  • Intervalles et égalités sur un même champ. Une garantie in 0..1500N face à une hypothèse in 0..1000N donne un avertissement contract-unmet. Il cite les deux côtés.
  • Unités. Les unités de temps sont converties. Les autres non : N face à kN donne une suggestion contract-unknown, et N face à ms n'est pas satisfait.
  • Échéances. Une garantie within 20ms satisfait une hypothèse within 50ms. Quand les deux nomment un événement after, un lien doit relier les deux ports.

contract-unknown couvre aussi deux autres cas :

  • une hypothèse sans aucune garantie sur son champ ;
  • une clause qu'archec ne sait pas lire, comme un or ou un appel.

Arche n'a pas de place pour les contrats : ils restent dans le modèle. archec sysml écrit un contrat sous la forme d'un requirement composé de assume constraint et de require constraint.

Exigences incompatibles#

archec verify --conflicts cherche les exigences qu'aucune implémentation ne peut satisfaire ensemble. FRET, de la NASA, fait de même ; ici, rien à installer.

Il lit les propriétés formal et les phrases EARS, sur les états de chaque part. Il joue une partie :

  1. À chaque tick, l'environnement choisit le message que reçoit chaque part.
  2. L'implémentation place alors chaque part dans l'un quelconque de ses états, en partant de son état initial. Les transitions de la machine sont une implémentation possible, pas une limite.
  3. Quand aucun choix d'états ne résiste à toutes les entrées, les exigences sont en conflit.
✗ conflict R1, R2 cannot hold together [req-conflict]
    at 10ms, when brakes receives watchdog, every state the parts can be in breaks R1 or R2
         0  brakes in Idle
      10ms  brakes receives watchdog → whatever the parts do:
              brakes in Idle     breaks R2
              brakes in Braking  breaks R2
              brakes in Holding  breaks R2
              brakes in Fault    breaks R1
    main.arche:31 R1: never brakes in Fault
    main.arche:32 R2: if brakes receives watchdog then brakes shall be in Fault

Chaque conflit est minimal : retirez l'une de ses exigences et les autres peuvent être tenues. archec le résout exactement, comme un jeu de sûreté sur un graphe fini. Ce graphe est formé des états des parts et, pour chaque exigence, de l'échéance la plus proche qu'elle attend.

Ce qui est borné :

  • Le temps se compte en ticks. Un tick est le diviseur commun des échéances. Il est rendu plus grossier au-delà de 16 ticks par échéance, chaque échéance étant arrondie au-dessus. --tick le fixe.
  • eventually et leads to sans within sont lus comme « dans les --horizon ticks » (8 par défaut).
  • Une réponse qui envoie un message n'est pas lue.

Ce que signifie une propriété#

archec verify --meaning [REQ…] montre ce que dit une propriété, sur deux chronogrammes : l'un où elle est vraie, l'autre où elle échoue. La spécification produite par archec doc --html les affiche sous chaque exigence.

R3 (brakes receives BRAKE_CMD) leads to brakes in Braking within 50ms
  Each time brakes receives BRAKE_CMD, brakes in Braking holds then or at most 50ms later.
    A = brakes receives BRAKE_CMD
    B = brakes in Braking
    holds:
      A ··▲·······▲·····
      B ·····██·····█···
          └───┘ 50ms
    fails:
      A ··▲·······▲·····
      B ············█···
          └───┘ 50ms ✗ B not in time

eventually et leads to acceptent une échéance, comme within 50ms. NuSMV les vérifie sans le temps, donc sans l'échéance. Les moniteurs (archec gen --monitors), archec replay et --conflicts vérifient l'échéance.

Model checkers#

Pour un model checker, archec écrit le modèle dans son langage d'entrée (voir Génération de code) :

  • archec gen --target uppaal écrit uppaal/model.xml et uppaal/model.q ;
  • archec gen --target nusmv écrit nusmv/model.smv.

Tests avec injection de fautes#

Un cas de test peut casser des choses exprès, dans la simulation d'Arche. On vérifie ainsi que le modèle y résiste :

failure-mode FM-RX "Receiver hangs" { of Car.brakes; effect "No more braking"; inject "freeze brakes" }

case TC-CAN-LOSS "Brake CAN lost" {
  at 20ms fault drop adcu.can_brake        // every message through that link end is lost
  within 60ms expect brakes.state == "SafeStop"
  at 100ms fault up adcu.can_brake         // works again
  at 120ms fault FM-RX                     // a failure mode's `inject`
}
faute ce que fait la simulation
drop part.port Les messages qui passent par cette extrémité de lien sont perdus. La trace les marque comme perdus (« fault: … »).
up part.port Met fin à un drop : les messages passent de nouveau.
delay part.port 5ms Chaque message qui y passe arrive 5 ms plus tard.
stuck part.port f=0, g=True Les messages qui y passent portent ces valeurs de champs.
freeze part / thaw part La part, et ce qu'elle contient, s'arrête : son code, ses timers et sa boîte de réception. Ce qu'elle avait en attente reprend quand elle est dégelée.
clear [target] Met fin aux fautes de la cible, ou à toutes.
FM-ID Exécute le inject du mode de défaillance.

Un instant accepte une faute à son heure : at 20ms fault drop adcu.can_brake. Le linter vérifie la faute et sa cible (bad-fault, unresolved). Chaque faute se compile en un appel d'observateur que le moteur d'Arche exécute, comme fault_drop("adcu.can_brake").

Couverture des tests#

archec test main.arche --coverage indique ce que les exécutions de test ont exercé du modèle. Dans VS Code, Run with Coverage dans le Test Explorer fait la même chose.

Coverage (car.yaml):
  states           6/8      75 %
      not covered: adcu: MinimalRisk
  transitions      5/10     50 %
      not covered: adcu: Autonomous -> MinimalRisk
  messages         4/10     40 %
      not covered: HEARTBEAT: adcu.can_brake -> brakes.can
  functions        9/9     100 %
  requirements     4/4     100 %

Ce qui est compté :

  • les états où l'on est entré ;
  • les transitions franchies ;
  • chaque message sur chaque lien qui le transporte ;
  • les fonctions appelées ;
  • les exigences vérifiées par un test dont les cas ont été exécutés.

Le rapport complet est conservé dans .archec/coverage.json. Dans l'éditeur (VS Code 1.88 ou plus récent), chaque état, transition, fonction et lien est marqué « exécuté » ou « non exécuté » sur sa ligne. Le simulateur d'Arche enregistre la couverture (arche-cli test --coverage <file>).

Vérification à l'exécution : les logs du système réel#

archec replay vérifie les exigences du modèle sur ce que le système réel a fait. Il lit :

  • un log CAN (candump, Vector ASC ou BLF) ;
  • un bag ROS 2 (MCAP) ;
  • des lignes JSON ;
  • la trace d'un firmware (archec gen --trace) : ses lignes state sont les états des parties, ses lignes send les messages envoyés (examples/greenhouse).

Le modèle décode chaque événement.

cd examples/brake-by-wire
archec replay main.arche logs/run-late.log logs/states-late.jsonl --junit replay.xml
  ✗ REQ-BRK-1   1 violation(s), the first at +0.070000 s (log time 1762790400.070000): brakes receives BRAKE_CMD at 50ms, not brakes in Braking 20ms later
  ✓ REQ-BRK-2   1 trigger(s)
  ✗ REQ-BRK-3   1 violation(s), the first at +0.150000 s (log time 1762790400.150000): brakes in Fault
  ✗ REQ-BRK-4   1 violation(s), the first at +0.050000 s (log time 1762790400.050000): BRAKE_CMD.force = 15000
  ✗ stale-after ctrl.status BRAKE_STATUS  1 violation(s), the first at +0.125000 s …: none for 70ms

Comment un log est décodé :

  • Un identifiant CAN correspond au message que la route … { id 0x100 } du déploiement y place. Ses octets sont décodés avec la même disposition que le DBC et le C et le Rust générés.
  • Un topic ROS 2 correspond au message de son type.
  • Un état n'apparaît pas sur un bus. Une ligne JSON comme {"t": …, "part": "brakes", "state": "Braking"} le fournit (à partir d'une trace de firmware, par exemple).

Ce qui est vérifié :

  • les exigences EARS, sous forme de moniteurs ;
  • les propriétés formal ;
  • une metric qui nomme un champ de message, par rapport à sa limit ;
  • les contrats et les budgets des chaînes ;
  • les range, les period et stale-after.

--json et --junit servent à la CI, comme avec archec ci.

--scenario replay.arche --from ctrl transforme le log en cas de test. Le cas envoie au modèle ce que ctrl a envoyé, aux mêmes instants. Il attend que les parts du modèle passent par les états par lesquels sont passées les parts réelles. archec test exécute alors le modèle sur les entrées réelles. Voir docs/commands.md.

Limites#

  • Les vérifications des machines à états n'exécutent pas de Python. Elles ne lisent une garde que si c'est une simple comparaison (self.speed < 10, not armed). Avec toute autre garde, elles en disent moins plutôt que de deviner : une transition morte derrière une telle garde n'est donc pas signalée.
  • Un composant dont le code appelle goto(…) n'est pas vérifié pour les interblocages.
  • Une clause de contrat qu'archec ne sait pas lire (un or, un appel) est contract-unknown, non vérifiée. Les unités autres que le temps ne sont pas converties.
  • --conflicts compte le temps en ticks, lit eventually et leads to sans within comme « dans les --horizon ticks », et ne lit pas une réponse qui envoie un message.
  • NuSMV vérifie les machines sans le temps : une échéance within est vérifiée par les moniteurs, archec replay et --conflicts, pas par NuSMV.
  • Sans NuSMV dans le PATH, chaque propriété est « non vérifiée » (code de sortie 2), jamais prouvée.
  • archec replay ne connaît un état que par le log. Une vérification qui demande un état que le log ne donne jamais est signalée comme non vérifiable. Une réponse encore attendue à la fin du log est non concluante, pas un échec.