Explications › Correspondance avec Arche

Explications

Correspondance entre arche-lang et Arche

Arche est l'outil de modélisation visuelle vers lequel arche-lang compile. archec build transforme vos fichiers .arche en projet Arche : un dossier de fichiers YAML qu'Arche sait ouvrir. Cette page indique ce que devient chaque déclaration dans ce dossier.

Une première compilation#

Enregistrez ceci sous main.arche :

message PING "Ping" { field seq: uint8 }

component Sensor "Sensor" {
  out data: data sends PING
}

component Logger "Logger" {
  in data: data receives PING
}

system Bench "Bench" {
  part sensor: Sensor
  part logger: Logger
  sensor.data -> logger.data
}
Diagramme : Bench
Ce qu’archec dessine depuis ce code : Bench
Essayer

Compilez-le :

archec build main.arche
✓ 9 files → arche-out (bench.yaml, models.yaml, templates.yaml, messages.yaml, types.yaml, colors.yaml, simulation.yaml, menu.yaml, layout.yaml)
  open with: arche --project /path/to/arche-out

Le système Bench est devenu le fichier de modèle bench.yaml. Il contient les deux parts sous forme de composants, avec leurs ports, et le lien qui les relie :

components:
  - id: sensor
    template: box
    name: Sensor
    ports:
      - id: data
        type: data
        direction: out
        messages:
          - PING
  …
links:
  - id: sensor-data-logger-data
    from: sensor.data
    to: logger.data

Les composants Sensor et Logger sont devenus des templates dans templates.yaml, et le message est parti dans messages.yaml.

Ce que devient chaque déclaration#

arche-lang Projet Arche
system X { … } fichier de modèle x.yaml (listé dans models.yaml) ; ses enfants sont les composants racines du canevas
component D de premier niveau un template dans templates.yaml, copié dans chaque part x: D (les valeurs de l'instance l'emportent, les listes fusionnent par id)
port, fn, var, memory, states, requirement imbriqué ports, functions, variables, memory, stateMachine, requirements sur le composant
a.p -> b.q { carries M; latency 1ms } links avec icd.messages et timing
canvas X { part at x, y; part size w, h } (ou at sur une part) la position et la size de chaque composant
purpose "…" les mainFunctions du composant
message, type/enum/struct, const messages.yaml, data-types.yaml, variables.yaml
requirement, actor, mission requirements.yaml, actors.yaml, missions.yaml
satisfies, verifies, derives, allocated-to, trace … traces.yaml, avec les adresses des éléments Arche (car.yaml#adcu:fn/plan)
test-plan, scenario, simulation testplans.yaml, scenarios.yaml, simulation.yaml
cores N, core id, os, ram, isa, freq sur un composant nature: hardware, cores: [{id, name, type}], hardware: {os, ram, …}. Le composant devient une cible sur laquelle tournent des threads.
deployment → binary … on cpu → process → thread / isr processes.yaml et threads.yaml (tasks.yaml sur un processeur RTOS ou bare-metal). Chaque part qu'un thread runs reçoit thread:.
period + step fn d'un thread un rt.timer à côté de la part. Il émet un top sur un port tick-<thread>, qui appelle fn.
route a.p -> b.q over bus { priority 3 } le timing.bus et la priority du lien, et le bitrate du bus. En simulation, le bus est un support partagé.
buffer queue + depth N + overflow, buffer sample sur un port ou un lien timing.queue / drop du lien. Un échantillon est une file d'un seul élément qui garde la valeur la plus récente.
kind, layer, tag, color, port-type kinds.yaml, layers.yaml, tags.yaml/tag-types.yaml, colors.yaml, types.yaml. Les entrées utilisées sans être déclarées sont ajoutées pour vous.
package p { … } rien en propre. Les noms sont qualifiés dans la source (p.X) ; les id restent globaux dans Arche.
interface I { messages …; fn op() }, port provides I / requires I un type de port dans types.yaml, avec messages, operations et extends ; les provides / requires des ports
part w: Wheel[4], component D(n: int32 = 8) quatre composants w_0 … w_3 ; les valeurs des paramètres de chaque instance, sous forme de variables
parameter, variant (+ variants a, b), study, viewpoint parameters.yaml, variants.yaml (+ variants: sur les composants et les liens), studies.yaml, viewpoints.yaml
budget power 150W un budget Arche : une variable avec rollup: sum (ou max), et en dessous les consommations, sous forme de variables du même nom
hazard, safety-goal safety.yaml (hazards, safetyGoals). failure-mode et gate sont vérifiés et mis en page, mais pas écrits.
decision une exigence de catégorie decision, avec des traces derives / satisfies
process … { lanes …; a: act; a -> b : x } un scénario à une seule séquence
equation der(x) = …, solver 1ms les equations et le solver du composant. Le simulateur d'Arche les intègre (RK4).
raw "file.yaml" ```yaml …``` ce fichier, tel quel. Utilisez-le pour tout ce que le langage ne modélise pas encore.

Les vérifications de chaque compilation#

Chaque compilation valide le YAML généré avec schemas/arche-project.schema.json avant d'écrire quoi que ce soit.

L'exemple de la voiture et l'exemple des patterns se chargent tous deux dans Arche avec 0 erreur selon le vérificateur d'Arche (arche-cli check). Leurs plans de test passent dans le simulateur d'Arche (arche-cli test) : 3/3 pour la voiture, 1/1 pour les patterns.

Corps de comportement#

Arche exécute le comportement en Python. Un corps peut s'écrire de deux façons :

  • Un corps ```arche est vérifié par archec. Il est écrit dans le projet sous la forme du Python qu'il représente :

    arche-lang Python
    wait 10ms await wait(ms(10))
    send p MSG { … } send(self.p, MSG(...))
    f() await self.f()
    goto State await goto("State")
  • Un corps ```python est écrit tel quel. Le linter ne vérifie que ce qu'il voit depuis le modèle : les appels à des fonctions sans corps et les await manquants.