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
}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
}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, oucmd.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
alwaysoueventually, et finir parwithin 20ms, ouwithin 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..1500Nface à une hypothèsein 0..1000Ndonne un avertissementcontract-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 20mssatisfait une hypothèsewithin 50ms. Quand les deux nomment un événementafter, 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
orou 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 :
- À chaque tick, l'environnement choisit le message que reçoit chaque part.
- 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.
- 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.
--tickle fixe. eventuallyetleads tosanswithinsont lus comme « dans les--horizonticks » (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écrituppaal/model.xmletuppaal/model.q;archec gen --target nusmvécritnusmv/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 lignesstatesont les états des parties, ses lignessendles 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
metricqui nomme un champ de message, par rapport à salimit; - les contrats et les budgets des chaînes ;
- les
range, lesperiodetstale-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) estcontract-unknown, non vérifiée. Les unités autres que le temps ne sont pas converties. --conflictscompte le temps en ticks, liteventuallyetleads tosanswithincomme « dans les--horizonticks », et ne lit pas une réponse qui envoie un message.- NuSMV vérifie les machines sans le temps : une échéance
withinest vérifiée par les moniteurs,archec replayet--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 replayne 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.