Analyser
Les commandes qui analysent un modèle et le système en marche : temps d’exécution, model checking, sûreté, cybersécurité et journaux.
Commandes : archec analyze · archec timing · archec verify · archec why · archec why-not · archec replay · archec live · archec study · archec safety · archec tara · archec parts · archec merge · archec observe · archec cad · archec synth
Sur cette page : En savoir plus sur ces commandes
| Commande | Ce qu’elle fait |
|---|---|
archec merge <base> <ours> <theirs> [--path p] [-o out] |
Une fusion à trois voies de fichiers .arche, déclaration par déclaration, comme pilote de fusion de git : ce qu’un seul côté a changé est repris, une déclaration changée des deux côtés est fusionnée de l’intérieur (ses propriétés par clé, ses membres par sorte et par nom), et seul un élément changé différemment des deux côtés est un conflit, marqué de son nom (<<<<<<< ours: Brake.pressure). Un côté qui ne s’analyse pas est fusionné ligne par ligne. archec merge --install écrit *.arche merge=arche dans .gitattributes et déclare le pilote dans la configuration git du dépôt. Code de sortie 1 en cas de conflit. |
archec verify <main.arche> [-o dir] [--json] |
Le model checker (NuSMV ou nuXmv, dans le PATH ou indiqué par NUSMV) sur la propriété formal de chaque exigence — never brakes in Fault, always …, eventually …, a in X leads to b in Y — et sur l’accessibilité de chaque état. Une propriété qui échoue est livrée avec son contre-exemple, sous forme de diagramme de séquence (<REQ>.mmd). Code de sortie 1 quand l’une échoue, 2 quand aucun model checker n’est trouvé. archec ci la lance comme étape verify. NuSMV ne connaît pas le temps : un within est laissé aux moniteurs, à archec replay et à --conflicts. Chaque propriété prouvée ou réfutée est enregistrée comme preuve pour archec status (--no-record : pas d’enregistrement). |
archec verify <main.arche> --conflicts [--tick 10ms] [--horizon 8] [--json] |
Les exigences qu’aucune implémentation ne peut satisfaire ensemble (la réalisabilité, telle que la vérifie FRET de la NASA), sans rien à installer : les propriétés formal et les phrases EARS, lues sur les états de chaque part. L’environnement choisit le message que reçoit chaque part à chaque tick (un seul, ou aucun) ; l’implémentation choisit ensuite l’état de chaque part, n’importe lequel (les transitions de la machine sont une implémentation parmi d’autres, pas une limite), à partir de son état initial. Un ensemble auquel aucun choix d’états ne survit est un conflit. Il est affiché sous forme d’ensemble minimal (retirez-en une exigence et les autres peuvent tenir), avec un témoin : les entrées tick par tick, les obligations attendues et, au dernier tick, chaque état restant avec l’exigence qu’il enfreint (req-conflict). L’analyse est bornée. Le temps se compte en ticks (le diviseur commun des échéances, rendu plus grossier au-delà de 16 ticks par échéance, chaque échéance arrondie au-dessus ; --tick le fixe). eventually et leads to sans within se lisent comme « dans les --horizon ticks » (8) : un conflit qui en cite un peut donc disparaître avec un horizon plus long. Une réponse EARS sans within arrive au tick de son déclencheur. Une réponse qui envoie un message n’est pas lue. Les régions orthogonales sont lues comme une seule. Un groupe d’exigences dont le jeu compte plus de 2 millions de coups n’est pas résolu (une note le signale). Les exigences qui ne partagent aucune part sont vérifiées séparément. Code de sortie 1 en cas de conflit. |
archec verify <main.arche> --meaning [REQ…] [--json] |
Ce que dit chaque propriété formal (ou celle que donne une phrase EARS) : une phrase et deux petites chronologies, l’une où elle tient, l’autre où elle échoue, telles que les dessine FRET de la NASA. archec doc --html et --md montrent la même chose sous chaque exigence. |
archec verify <main.arche> --modelica [--system S] [--results S_res.csv] [--case TC] [--tol 0.01] [-o dir] [--json] |
Chaque système qui a des plans de test, tel que l’écrit gen --target modelica, simulé par OpenModelica (omc dans le PATH, ou OMC=… ; le paquet et les résultats dans <dir>/modelica/). Les attendus de ses plans de test sont lus sur les résultats (at, within, never:, always:, le expect at 1s: … d’une étape ; les noms du réseau ou les physics.x_y d’Arche). archec physics tourne à côté sur le même réseau : le plus grand écart de chaque état est comparé à --tol de son étendue. --results : un calcul fait ailleurs (le CSV d’OpenModelica, ou tout CSV avec le temps en premier et une colonne par variable, sous son nom Modelica ou son nom dans le réseau). Code de sortie 1 quand un cas échoue ou que les deux divergent, 2 sans OpenModelica ni --results. Voir physique. |
archec why <main.arche> (--test <case> | --trace <file> | --for 10s) ["<event>"] [--json] [--all] |
Une exécution expliquée (voir why.md). L’exécution est un cas de test sur le simulateur d’archec (--test), une trace (--trace : les lignes arche-trace ou le JSON Chrome de archec gen --target c|embassy --trace, ou archec sim --json), ou une simple exécution (--for). Sans événement, sa chronologie : les messages (un message répété est replié), chaque changement d’état avec sa transition, sa ligne du modèle et les valeurs que sa garde a lues, les variables, les attentes du test au moment où chacune a été tranchée, et les exigences vérifiées pendant l’exécution. Avec un événement — un état ("fan Running"), un message ("ctl sends FAN #2"), un port (ctl.fan last), une variable ("air.temperature at 1s") —, ses causes jusqu’à la racine : la transition, la garde et ses valeurs, le message et l’endroit du modèle où il est envoyé, le thread qui l’a envoyé, la variable ou le test derrière la valeur, chacun avec son fichier:ligne, son instant et le temps entre deux maillons. Puis le temps écoulé depuis la lecture, et chaque exigence qui borne ce délai (within EARS, ou un within dans le texte d’une exigence que satisfait une part de la chaîne), tenue ou non. Sur une trace, ce qui a causé quoi est déduit du modèle et de l’ordre dans le temps. Code de sortie 1 quand l’événement n’est pas dans l’exécution. |
archec why-not <main.arche> (--test <case> | --trace <file> | --for 10s) "<transition or event>" [--json] |
Pourquoi une transition ("Cooling -> Idle", "ctl Cooling -> Idle on READING"), un état ("fan Running") ou un message n’a jamais eu lieu : son état de départ n’a jamais été actif (et pourquoi les chemins qui y mènent n’ont pas été pris), son déclencheur n’est jamais arrivé pendant qu’il l’était (et qui aurait dû l’envoyer : un port relié à rien, un émetteur qui n’a jamais envoyé), ou sa garde n’a jamais été vraie (et la valeur la plus proche atteinte : « the lowest celsius was 26.3 °C »). Sur une trace sans valeurs (pas d’enregistrements value), la commande dit qu’elle ne peut pas trancher. |
archec replay <main.arche> <log>… [--format f] [--deployment D] [--bus can0=<bus>] [--period-tolerance 50%] [--json] [--junit report.xml] [--strict] [--events] [--scenario out.arche [--from part,…]] |
La vérification à l’exécution : les journaux du système réel vérifiés par rapport au modèle. La commande lit candump (le format par défaut et -L), Vector ASC et BLF, ROS 2 MCAP (chunks stockés, lz4 ou zstd), des lignes JSON ({"t", "msg", "from", "value"}, ou {"t", "part", "state"} pour l’état d’une part) et des traces distribuées (OpenTelemetry OTLP JSON, Jaeger, Zipkin : chaque appel d’un service à un autre est un message, sous le nom que lui donne archec observe ou sous son libellé). Plusieurs journaux forment une seule trace. Une trame CAN est le message que la route de son déploiement associe à cet identifiant, décodé selon la disposition que partagent le DBC et le code C et Rust généré. Un message ROS 2 est décodé selon son type (CDR, tel que --target ros2 écrit le .msg). Viennent ensuite les vérifications, chacune avec l’heure de sa première violation : les exigences EARS comme moniteurs (le déclencheur, le while, la réponse within son échéance), les propriétés formal (never, always, implies, leads to, eventually et leur within), une metric qui est un champ de message, comparée à sa limit, les contrats (assume, guarantee … within 30ms after M), les budgets des chaînes (la dernière entrée prise comme cause : une borne inférieure), la range de chaque champ, la period de chaque message (± 50 %), le stale-after de chaque port. Ce qui lit un état a besoin des états dans le journal, sinon ce n’est pas vérifiable. Une réponse que le journal n’atteint pas avant sa fin n’est pas concluante (--strict la fait échouer). JUnit comme archec ci. --scenario out.arche écrit le journal sous forme de cas de test pour le simulateur : ce qu’ont envoyé les parts citées par --from (par défaut : les parts sans machine à états) est envoyé au modèle aux instants où c’est arrivé, et chaque état que donne le journal après le premier est attendu. Incluez-le, et archec test montre où le modèle ne fait pas ce qu’a fait le système. Code de sortie 1 en cas d’échec, 2 quand un journal est illisible. Chaque exigence vérifiée est enregistrée comme preuve pour archec status : --board <id> ou --place renode dit d’où vient le journal, --firmware <file> ce qui a tourné (--no-record : pas d’enregistrement). La trace d’un firmware dit de quel build il s’agit dans sa première ligne (le build que fait tourner une carte). Si c’est le build de ce modèle, il est gardé dans l’enregistrement. Si c’est un autre build, cela est dit d’abord — the board runs an older build: rebuild and flash —, rien n’est enregistré et le code de sortie est 1 (--any-build : jugé quand même). |
archec observe <trace>… [--states] [-o observed.arche] [--model main.arche] [--json] [--format otlp|jaeger|zipkin] [--system Name] [-k 2] |
Le comportement du système en marche, retrouvé à partir de ses traces : OTLP JSON d’OpenTelemetry (les lignes de l’exportateur fichier, ou un seul objet), un export JSON de Jaeger, Zipkin v2 JSON. Un span dont le parent a tourné dans un autre service est un appel de ce service vers le sien (le nom du span serveur, la durée entre le début et la fin du span client). Un span client sans rien en dessous va vers son peer.service, son db.system ou son server.address. Un span dans le même service est l’une de ses étapes (une fn). La commande écrit un .arche (-o, sinon sur la sortie standard) : un message par opération (POST /orders → POST_ORDERS, un Svc/Charge gRPC → CHARGE), un composant et une part par service (outside envoie ce qui démarre une trace), un lien par appelant et appelé avec, pour chaque opération, son nombre d’appels, son p50, son p95 et ses erreurs, et sa latency égale au temps sur le fil. Elle écrit aussi un scénario par chemin qu’a suivi une requête (les traces regroupées selon la forme de leurs appels : des appels qui se chevauchent forment un par, le même appel répété à la suite un loop), avec le nombre de traces passées par là et le p50 et le p95 de chaque réponse, ou son erreur. --states : une machine à états par service qui en attend un autre, tirée de ce qu’il a reçu requête par requête (la requête, puis chaque réponse). Ses états portent le nom des réponses qu’ils attendent ; deux états sont fusionnés quand ils attendent la même chose et que les -k événements suivants sont les mêmes (k-tails). Un commentaire // observed: indique dans combien de traces chaque transition a été prise. Le fichier passe les vérifications et se dessine (archec diagram <file> <scenario>, <System.part>.states). --model main.arche : les traces confrontées à un modèle à la place — les services qui ne sont aucune part, les appels qui ne sont ni un lien ni un message du modèle, les liens jamais vus, la deadline d’un lien comparée au temps sur le fil, un timeout comparé aux réponses, et ce que vérifie archec replay (EARS, formal, périodes) sur les appels pris comme messages. --json pour la CI. Code de sortie 1 quand il manque quelque chose au modèle ou qu’une vérification échoue, 2 quand un fichier ne contient aucun span. |
archec analyze <main.arche> [--json] |
Les temps de chaque déploiement : charge des cœurs, temps de réponse comparés aux échéances, charge des bus, mémoire, chaînes de bout en bout. Code de sortie 1 quand un cœur est surchargé ou qu’une échéance ou un budget de chaîne peut être dépassé. |
archec timing <main.arche> <trace…> [--deployment D] [--json] [--junit report.xml] [--html report.html] |
Ce qu’a fait une exécution, à côté de ce qu’avait prédit archec analyze. Les traces sont celles que produit archec gen --trace — des lignes arche-trace <ns> <kind> <name> <arg> venues d’un UART, de defmt ou d’un journal (tout ce qui précède arche-trace sur une ligne est ignoré), ou du JSON de trace Chrome — ou toute trace Chrome dont les tranches portent le nom des threads du modèle, ou sont les plus externes sur un thread ainsi nommé. Par thread : activations, période et gigue, temps de réponse depuis la libération (min / moy / p99 / max) et temps d’exécution, préemption déduite. Par cœur : la part de la trace où ses threads étaient actifs. Par bus : la charge des trames qui y passent. Par chaîne : la latence d’un début à sa fin. Une mesure pire que la prédiction est signalée OPTIMISTIC (l’analyse est fausse : un wcet trop petit, un blocage qu’elle ne voit pas), une mesure au-delà d’une échéance ou d’un budget MISS ; dans les deux cas, code de sortie 1 (2 quand aucun événement ne correspond au modèle). --junit : un cas de test par thread, cœur, bus et chaîne, comme les écrit archec ci. --html : une seule page autonome. La réponse d’un thread d’événement compte à partir de son démarrage. Une chaîne dont le début et la fin sont dans deux traces considère que leurs horloges n’en font qu’une. Ce que les traces disent de chaque exigence (ses chaînes, ses threads et ses moniteurs) est enregistré comme preuve pour archec status : --board <id> ou --place renode dit où elles ont été prises, --firmware <file> ce qui a tourné (--no-record : pas d’enregistrement). La trace d’un firmware dit de quel build il s’agit dans sa première ligne (le build que fait tourner une carte). Si c’est le build de ce modèle, il est gardé dans l’enregistrement. Si c’est un autre build, cela est dit d’abord — the board runs an older build: rebuild and flash —, rien n’est enregistré et le code de sortie est 1 (--any-build : jugé quand même). |
archec live [main.arche] [--deployment D] [--replay <trace|dir>…] [--json] [--once] [--duration 10s] [--html report.html] [-o dir] [--no-compose] |
Le modèle vivant : ce que fait un système en marche fait passer les exigences, chaînes, threads et conteneurs du modèle à l’état réussi, échoué ou en attente, au fil de l’exécution. Sans --replay, les conteneurs du déploiement (celui que nomme --deployment, sinon le premier qui a des conteneurs) sont générés (--target c --trace compilé avec make LIVE=1, --target containerd, dans -o, sinon dans un dossier temporaire), construits avec podman build et démarrés avec podman compose (simple podman run avec --no-compose ou sans compose). Leurs journaux sont suivis et podman stats est interrogé toutes les 2 s. L’état est évalué chaque seconde et les conteneurs sont supprimés à la fin (Ctrl-C, ou --duration). --replay <file|dir>… : des traces déjà écrites (lignes arche-trace, un journal qui en contient, JSON de trace Chrome), évaluées une seule fois. Une chaîne ou un thread échoue sur un dépassement (un budget, une échéance ; pire que prévu ne fait que le signaler). Un conteneur au-delà de sa memory-limit ou arrêté échoue. Une exigence échoue quand un moniteur à l’exécution le dit (arche-trace <ns> monitor <REQ-ID> 1 ; un invariant, tracé seulement quand il échoue, réussit par son silence pendant que d’autres moniteurs rendent compte) ou quand ce qui la satisfait échoue — un chain … { satisfies R }, un thread ou un conteneur qui exécute une part qui satisfait R. Elle réussit quand ceux-ci réussissent, et reste en attente jusque-là. Chaque état est aussi gardé dans .arche/live.json à côté du fichier principal (remplacé en entier à chaque rafraîchissement). --json : un état par ligne à chaque rafraîchissement (ndjson, rien d’autre sur la sortie standard), chaque élément avec son file et sa line ; --replay peut être donné une fois par fichier. --once : tourne pendant --duration (10 s), affiche l’état final, code de sortie 1 quand quelque chose échoue. --html : l’état final sur une seule page. |
archec study <main.arche> <id> [--json] |
Une étude sur les tolérances des paramètres : pire cas (l’étendue de chaque sortie, et le coin où elle se trouve) ou Monte-Carlo (moyenne, σ, percentiles). Elle s’appuie sur l’évaluation d’études propre à Arche (vendor/arche.js), pas sur un simulateur. Pour faire varier un paramètre au cours d’une exécution du réseau ou du comportement, utilisez archec physics --batch ou archec sim --batch. |
archec parts [main.arche] [--provider nexar|digikey|mouser] [--offline] [--dry-run] [--json] |
Chaque référence de la nomenclature (product { vendor "…"; part-number "…" }), une seule fois, recherchée chez un distributeur : son stock, ses prix par quantité, son cycle de vie (active, NRND, fin de vie), gardés avec la date dans .arche/parts-cache.json. Nexar (Octopart) : NEXAR_TOKEN, ou NEXAR_CLIENT_ID + NEXAR_CLIENT_SECRET. DigiKey (Product Information v4) : DIGIKEY_CLIENT_ID + DIGIKEY_CLIENT_SECRET. Mouser (Search API v1) : MOUSER_API_KEY. C’est le premier dont les clés sont définies qui sert, sauf avec --provider ; --url ou ARCHE_PARTS_URL pour un autre serveur. --offline : le cache seulement. --dry-run : les requêtes, sans les clés, rien n’est envoyé. Code de sortie 1 pour une référence en fin de vie, NRND, en rupture de stock ou inconnue. archec check avertit ensuite de ces cas à partir du cache ([part-lifecycle], [part-stock]), avec la date — seulement si le cache existe, et jamais via le réseau. Hors ligne par défaut : archec config allow parts l’autorise à interroger le distributeur (ai-engineering.md). |
archec safety <main.arche> [--json] |
L’analyse de sûreté : chaque danger avec son ASIL et son taux, écrits et déduits ; l’arbre de défaillances de chaque danger qui a error … on …, déduit du modèle d’erreurs des parts (produces, contains, turns, from), avec ses coupes minimales ; l’AMDE qui en découle — chaque source d’erreur, où va son erreur, les dangers auxquels elle mène ; la STPA — chaque action de contrôle selon les quatre types d’actions de contrôle dangereuses, les UCA avec leurs dangers, leurs contraintes et leurs scénarios de perte. Code de sortie 1 quand ce qui est déduit et ce qui est écrit divergent (fta-mismatch, fmea-mismatch) ou que la STPA a un manque (stpa-incomplete, stpa-no-path, uca-untraced). |
archec tara <main.arche> [--json] |
L’analyse des risques de cybersécurité (ISO/SAE 21434) : l’impact, la faisabilité, le risque et le CAL de chaque menace. Code de sortie 1 quand un risque de niveau 4 ou 5 n’a pas de traitement. |
archec cad [main.arche] [--json] [--force] [--only <Name>]… [--no-run] [--python <exe>] [--html <page.html>] [--no-record] |
La géométrie du modèle, construite et vérifiée (la CAO en code). Chaque fichier cad "cad/part.py" (build123d) d’un composant qui a changé est exécuté, et écrit dans build/cad/ en STEP, STL et GLB. Sa taille, son volume, sa masse (selon son material ou sa density), son centre de masse, son inertie et ses ancrages sont mesurés. Les parts de chaque système sont placées (at box.mount). Les limites des exigences (limit Enclosure.mass <= 250g) et les distances (clearance board, relay >= 2mm) sont vérifiées, et enregistrées pour archec status. De même pour les trous de fixation d’une carte face aux entretoises qui la tiennent (fits board, box), les références de ce qui est acheté (sourced Assembly), et l’ERC et le DRC de KiCad pour une carte qui nomme son pcb, quand kicad-cli est installé (sautés, et signalés, sinon). --no-run vérifie ce qui est déjà mesuré, sans moteur de CAO. --force exécute à nouveau chaque fichier. --html écrit une page 3D du résultat. Le moteur est fourni avec les builds de l’extension pour chaque plateforme, ou c’est un Python qui a build123d (ARCHE_CAD_PYTHON) : archec ne le télécharge jamais. |
archec synth [main.arche] [--device <name>] [--system <S>] [--deployment <D>] [-o <dir>] [--virtual-pins] [--bitstream [--constraints <pins.pcf|pins.lpf>]] [--seed <n>] [--json] [--verbose] [--no-record] |
Les composants FPGA synthétisés, placés et routés pour le FPGA cible du modèle (composants FPGA) : le chip de sa part kind fpga (chip "iCE40UP5K-SG48", chip "LFE5U-25F-6BG381"), ou --device. Le VHDL généré est lu dans Yosys via GHDL, projeté sur les cellules du composant, puis placé et routé avec nextpnr. La commande dit les LUT, bascules, blocs de RAM et blocs DSP que prend la conception, et la fréquence la plus haute à laquelle chaque horloge peut tourner (fmax) face à celle que lui donne le modèle. Une exigence les borne : limit Pwm.luts <= 500, limit Pwm.fmax >= 100MHz. Ce qui est mesuré est enregistré pour archec status (synth, un échelon au-dessus de ghdl). Un top qui a plus de broches que le boîtier est placé avec des broches virtuelles. --bitstream écrit le fichier à charger (icepack, ecppack), avec les broches de --constraints ; le flasher vous revient. Les outils ne sont dans aucune build de l’extension : archec synth --install-tools dit où se trouve l’OSS CAD Suite épinglée (environ 500 Mo ; archec ne la télécharge pas), et avec --archive <file> vérifie le fichier par son sha256 et le décompresse dans ~/.arche/fpga. Code de sortie 0 : la synthèse réussit, tient ses horloges et ses limites ; 1 : non ; 2 : impossible de l’exécuter. |
archec why-not <main.arche> <requirement | "Enclosure.mass" | "clearance board, relay"> [--json] |
Pourquoi une limite, une distance ou un ajustement sur la géométrie n’est pas tenu : ce qu’archec cad a mesuré, de combien cela manque, et ce qui le ferait tenir. |
En savoir plus sur ces commandes#
Pendant qu’un système tourne, archec live montre quelles exigences, chaînes, threads et conteneurs réussissent ou échouent.
archec live-fix REQ-1 demande à Claude pourquoi l’une d’elles échoue — à partir des preuves, des temps mesurés et prédits
et des déclarations en jeu — et propose des modifications des fichiers .arche, chacune vérifiée par rapport au texte de sa
ligne. Dans VS Code, « Arche: Start Live » colore ces lignes, et « Explain & fix with Claude » affiche un aperçu des modifications.
--dry-run montre ce qui serait envoyé.
archec parts recherche les références de la nomenclature chez Nexar (Octopart), DigiKey ou Mouser —
stock, prix par quantité, cycle de vie — et garde les réponses avec leur date dans .arche/parts-cache.json.
archec check avertit ensuite, à partir de ce seul cache, d’une référence en fin de vie, déconseillée pour
les nouvelles conceptions ou en rupture de stock.