Guides pratiques › Déployer sur le matériel

Guides pratiques

Déploiement : matériel, contexte d'exécution, communication

Un deployment indique où s'exécutent les parts d'un système : sur quel processeur, dans quel programme, sur quel thread. archec le vérifie, prédit ses temps de réponse et peut le suivre pendant l'exécution. Un même système peut avoir plusieurs déploiements.

Un premier déploiement#

Deux parts : pinger envoie PING toutes les 5 ms, counter le reçoit. Les deux tournent sur un seul microcontrôleur.

message PING { n: uint16; period 5ms }

component Ticker {
  out tx: data sends PING
  fn tick { wcet 1ms }
}

component Counter {
  in rx: data receives PING { depth 8 }
  fn count { wcet 200us }
}

component Mcu {
  kind processor
  compute { cores 1; os freertos }
}

system App {
  part pinger:  Ticker
  part counter: Counter
  pinger.tx -> counter.rx
}

system Board {
  part mcu: Mcu
}

deployment D {
  system App
  platform Board
  binary fw on mcu {
    thread fast { runs pinger; period 5ms; step tick; priority 2 }
    thread slow { runs counter; priority 1; queue 8 }
  }
  chain ping { through pinger, counter; budget 10ms }
}
Diagramme : App
Ce qu’archec dessine depuis ce code : App
Essayer

Lisez-le de haut en bas :

  • App est le système logique : il dit quelles sont les parts.
  • Board est la plateforme : le matériel. Mcu est un processeur à un cœur, sous FreeRTOS.
  • D place le programme fw sur le processeur. Il a deux threads. fast exécute pinger toutes les 5 ms et appelle son tick. slow exécute counter à l'arrivée d'un message.
  • wcet est le temps d'exécution au pire cas d'une fonction. L'analyse temporelle part de cette valeur.
  • Une chain est un chemin à travers les parts, avec un budget de temps de bout en bout.

Vérifiez-le et demandez son analyse temporelle :

archec check main.arche
archec analyze main.arche
✓ no errors
Deployment D

Threads
  thread            where                    prio      C          T          D          R
  fast              mcu/cpu0                 2         1ms        5ms        5ms        1ms      ok
  slow              mcu/cpu0                 1         200us      5ms        5ms        1.2ms    ok

Cores
  mcu/cpu0                   24 %      (RM bound 82.8 %)  fast, slow

Chain ping
  pinger             fast         wait ≤ 5ms      run 1ms      → 0ns (same-process)
  counter            slow         wait ≤ 0ns      run 1.2ms
  worst case 7.2ms — budget 10ms ok

C est le temps d'exécution, T la période, D l'échéance et R le temps de réponse au pire cas. archec analyze sort avec le code 1 quand un cœur est surchargé, ou quand une échéance ou le budget d'une chaîne peut être dépassé.

Trois questions séparées#

Le modèle logique (un system) dit quelles sont les parts. Trois autres questions en sont séparées, pour qu'un même système puisse être déployé de plusieurs façons.

Le matériel : où les choses s'exécutent.

  • Un processeur est un composant doté de cœurs (cores 8, core safety { type "Cortex-R52" }), d'un os et de ram.
  • Un bus est un composant avec kind bus et un bitrate.
  • Placez-les dans un system de plateforme.

Le contexte d'exécution : ce qui s'exécute.

  • Un deployment place des binary (des programmes) sur des processeurs.
  • Un binaire contient des process. Un processus est un espace d'adressage. Il n'y a pas de processus sur un RTOS.
  • Les processus contiennent des thread et des isr (gestionnaires d'interruption). Chacun accepte priority, period, deadline, core et stack.
  • Un thread exécute des parts (runs). Leurs fonctions, leurs handlers et leur machine à états s'exécutent sur ce thread, un à la fois.

La communication : comment deux parts échangent, sur les ports et les liens.

  • pattern dit qui attend et combien reçoivent : fire-and-forget (par défaut), request-reply, pub-sub ou broadcast.
  • buffer dit ce que garde le récepteur : queue (avec depth et overflow), sample ou stream.
  • timeout, deadline, stale-after, reliability et topic les complètent.

Un déploiement plus grand, sur deux processeurs et un bus CAN :

deployment Vehicle "L4 stack on the vehicle" {
  system Car                        // what runs
  platform CarHw                    // where

  binary adas "adas-stack" on adcu_soc {
    process driving { core cpu2; thread drive { runs adcu; priority 80 } }
  }
  binary brake_fw "brake.elf" on brake_mcu {      // FreeRTOS: tasks, no process
    thread ctl { runs brakes; period 1ms; step regulate; priority 10 }
  }
  route adcu.can_brake -> brakes.can over chassis_can { priority 3 }
  chain obstacle { through adcu, brakes; budget 100ms }
}
Diagramme : L4 stack on the vehicle
Ce qu’archec dessine depuis ce code : L4 stack on the vehicle

L'exemple complet se trouve dans examples/autonomous-car/deployment.arche.

Comment un lien est transporté#

Le transport de chaque lien découle de l'endroit où s'exécutent ses deux extrémités :

  • sur le même thread ;
  • dans le même processus ;
  • sur le même processeur, avec la latence ipc-latency du processeur ;
  • sur un autre processeur, par la route du lien sur un bus.

Un lien entre deux processeurs sans route est une erreur.

Ce que signale le linter#

  • une part dotée d'un comportement qui ne s'exécute nulle part ;
  • un cœur que le processeur n'a pas ;
  • un bus qui ne relie pas les deux processeurs ;
  • des patterns qui ne correspondent pas aux deux extrémités ;
  • une requête sans handler pour la traiter ;
  • une file non bornée sur un RTOS ;
  • des niveaux de sûreté mélangés dans un même espace d'adressage.

Ce que calcule archec analyze#

archec analyze (et l'éditeur) calcule :

  • la charge de chaque cœur et les temps de réponse à priorités fixes, à partir de wcet, period et priority ;
  • la charge de chaque bus, à partir de la taille et de la période des messages ;
  • la latence au pire cas de chaque chain, comparée à son budget.

Temps mesurés#

Vous pouvez ensuite mesurer ce que fait vraiment le système et le comparer à la prédiction.

  1. archec gen --target c --trace (ou --target embassy --trace) insère des points de trace dans le code généré. Ils enregistrent l'activation et la fin de chaque thread, les messages, les trames de bus et les chaînes.
  2. Exécutez le programme. Il écrit une trace.
  3. archec timing main.arche <trace…> lit les traces, ou tout JSON au format Chrome trace. Pour chaque thread, il affiche la période, la gigue et le temps de réponse. Il affiche aussi la charge de chaque cœur, celle de chaque bus et la latence de chaque chaîne, à côté de la prédiction.

Un résultat pire que prévu signifie que l'analyse est optimiste : un wcet est trop petit. Dépasser une échéance ou un budget est un échec. Voir examples/timing, et examples/greenhouse pour une trace venue d'une carte (ou de Renode) par son UART.

Compilé en mode live (make LIVE=1, ou -DARCHE_TRACE_LIVE), le C écrit chaque ligne de trace sur stdout au fil de l'eau. Parmi ces lignes figure l'état dans lequel entre la machine de chaque part, par exemple arche-trace <ns> state counter.Seen 0. On peut alors suivre un système en cours d'exécution (voir Live).

Exécution et mémoire#

Un thread est un objet actif : il exécute ses parts un message à la fois, en puisant dans sa file.

  • queue 32 dimensionne cette file. Sur un RTOS, un thread réveillé par des messages doit l'indiquer.
  • affinity cpu1, cpu2 donne les cœurs sur lesquels le thread peut tourner, quand un seul core ne suffit pas à le dire.
  • Un thread peut aussi exécuter un seul port d'une part. runs sink.metrics traite les messages de ce port sur ce thread, et non sur le thread de la part.

Une part qu'aucun thread n'exécute peut quand même s'exécuter : placez-la (place) dans un processus. Elle est alors :

  • passive : elle s'exécute dans les threads de ses appelants ;
  • ou protected : elle s'exécute dans les threads de ses appelants, un appelant à la fois.

execution active indique que la part a besoin de son propre thread.

La mémoire provient d'allocateurs.

  • Un processeur déclare ses mémoires : memory ddr { size 1GiB; shared } (une memory sans type ni adresse).
  • Un allocator dans le déploiement, un binaire ou un processus prend ses blocs dans l'une de ces mémoires, ou dans un allocateur parent.
  • Un place indique ensuite d'où vient la mémoire d'une part, pour chaque usage :
    • hrt : ses données temps réel ; lrt : le reste ;
    • saved et tmp : la mémoire de travail d'un algorithme ;
    • comm : ce que ses ports sérialisent.
  • Le buffering d'un port de flux de données indique la taille de ses buffers, si les consommateurs les copient ou les partagent, quand ils sont libérés et d'où ils viennent.
deployment Target {
  allocator heap { kind heap; block-size 1MiB; memory cpu.ddr; shared }
  binary chain on cpu {
    options mygen { orb "rteorb" }
    process main {
      allocator frames { kind pool; block-size 4KiB; blocks 32; parent heap; alignment 64 }
      thread work { runs chain; priority 50; queue 32; affinity cpu1, cpu2 }
      thread watch { runs sink.metrics; queue 8 }
      place log { execution protected; memory hrt frames }
      place chain.f1 { memory saved frames; memory tmp frames }
      place chain.split.input {
        memory comm frames
        buffering { max-size 4KiB; transfer copy; destroy after-processing; allocator frames }
      }
    }
  }
}

Le linter signale :

  • une part active qu'aucun thread n'exécute, et une part passive qu'un thread exécute ;
  • un thread qui exécute un port de sortie ;
  • un allocateur appartenant à un autre processus ;
  • un allocateur dans une mémoire locale qui est mapped ;
  • les débordements : un allocateur enfant plus grand qu'un bloc de son parent, plus d'usages que de blocs, un buffer plus grand qu'un bloc, des allocateurs plus grands que leur mémoire.

Un buffer partagé et libéré dès son envoi est une erreur : ses consommateurs liraient de la mémoire libérée.

options <generator> { … } sur un binaire (ou un processus) fixe les options de ce générateur pour lui seul, par-dessus celles du projet. options { … } les fixe pour tous les générateurs. Le modèle du générateur donne à chaque binaire et à chaque processus ses options résolues. Voir examples/signal-chain.

Live#

archec live main.arche lance les conteneurs d'un déploiement et affiche l'état du modèle pendant leur exécution.

  • Il exécute les conteneurs sous podman. Le C généré est tracé en direct (--target containerd).
  • Il suit leurs logs et podman stats.
  • Chaque exigence, chaîne, thread et conteneur est pass, fail ou pending.

Ce qui fait échouer quoi :

  • Une chaîne qui dépasse son budget fait échouer l'exigence qu'elle satisfait (satisfies).
  • Un thread en retard, ou un conteneur qui dépasse sa memory-limit, fait échouer ce que ses parts satisfont.
  • La ligne arche-trace <ns> monitor REQ-1 1 d'un moniteur d'exécution fait échouer REQ-1.

Options :

  • --json diffuse l'état, un JSON par ligne, chaque élément avec son fichier et sa ligne. L'éditeur le lit.
  • --once --duration 30s sert de garde-fou en CI.
  • --replay trace.log évalue des traces déjà écrites.

Conteneurs#

Un container contient des binaires, au lieu de les placer directement sur le processeur. Il lui faut un processeur Linux dont le compute indique runtime containerd. L'image du conteneur porte le nom de son identifiant. Ses binaires reprennent son on.

Il déclare aussi son cgroup et son bac à sable :

  • les cœurs qu'il peut utiliser (core, son cpuset) ;
  • memory-limit ;
  • network host, bridge ou none ;
  • les device de l'hôte qu'il voit (/dev/ttyS1) ;
  • les capabilities Linux : sys_nice pour les threads en policy fifo, all pour un conteneur privilégié ;
  • des variables d'environnement (prop NAME = "value").
container driving "registry.local/l4/driving:0.3" on adcu_soc {
  core cpu2, cpu3, cpu4, cpu5; memory-limit 4GiB; network host
  capabilities sys_nice; prop RUST_LOG = "info"
  binary adas { language rust; thread drive { runs adcu; core cpu2; priority 80; policy fifo } }
}

Un conteneur doté d'une memory-limit compte une seule fois dans la ram de son processeur. Ses processus sont vérifiés par rapport à cette limite. Un lien entre deux conteneurs coûte la ipc-latency du processeur. Quand l'un d'eux est sur un réseau bridge, il coûte la latency de ce conteneur.

Le linter signale :

  • un conteneur sur un processeur non Linux, ou sur un processeur sans runtime ;
  • un thread hors des cœurs de son conteneur ;
  • un thread temps réel sans sys_nice ;
  • un lien qui sort d'un conteneur network none ;
  • un conteneur sur un bus CAN sans network host (le can0 de SocketCAN est une interface réseau, pas un périphérique) ;
  • un conteneur sur un autre bus (une ligne série) qui ne voit aucun périphérique ;
  • un binaire dans un conteneur qui déclare aussi on.

archec gen --target containerd écrit les images et les fichiers compose. --target k8s écrit les manifestes Kubernetes (k3s) qui les exécutent, chacun épinglé au nœud de son processeur (voir Génération de code).

Un conteneur par processus#

packaging container met chaque processus dans son propre conteneur, sans avoir à les écrire un par un. Chaque processus d'un binaire sur un processeur Linux reçoit un conteneur :

  • nommé d'après le processus, sur ce processeur ;
  • avec le ou les cœurs du processus comme cpuset, et sa memory-limit ;
  • sur le réseau de l'hôte ;
  • avec sys_nice quand l'un de ses threads est temps réel.

Les threads d'un binaire qui ne sont dans aucun processus partagent un conteneur, nommé d'après le binaire. Les conteneurs que vous écrivez vous-même restent tels quels : écrivez-en un explicitement pour lui donner une image, un périphérique ou un autre réseau.

deployment Vehicle {
  packaging container
  binary adas on adcu_soc {
    process driving { core cpu2; memory-limit 4GiB; thread drive { runs adcu; policy fifo } }
    process island { core safety; thread guard { runs adcu.brakes_path } }
  }
}

Dans le projet Arche#

Les conteneurs du déploiement simulé vont dans containers.yaml : processeur, cores du cpuset, memoryLimit, network, latency, image, périphériques, capabilities et env. Un processus dans un conteneur, ou un thread sans processus, indique container: <id> et garde sa propre cible et son propre cœur. La page Hardware d'Arche regroupe les threads de chaque cœur par conteneur.

Limites#

  • L'analyse temporelle part du wcet que vous écrivez. Elle ne le mesure pas : un wcet trop petit donne une prédiction optimiste. Comparez avec une trace mesurée (archec timing).
  • archec live n'exécute les conteneurs qu'avec podman.
  • Les conteneurs exigent un processeur Linux avec runtime containerd.
  • La simulation d'Arche exécute les threads d'un conteneur comme n'importe quel autre thread. Le conteneur ne les regroupe que sur la page Hardware.