Holarch

Guide · SysML v2

SysML v1 et v2 : en quoi les deux langages diffèrent

Écouter ce guide (audio en anglais) 20 min

SysML v1 et SysML v2 partagent un objectif et de nombreux noms, mais SysML v2 est un nouveau langage plutôt qu'une révision. Ce guide compare les deux côte à côte : le fondement, les définitions et usages, la notation textuelle, les unités, les ports, le comportement, les exigences, les vues, l'API, et ce qu'implique une migration de v1 vers v2.

Sur cette page
  1. En un coup d'œil
  2. Fondement : un profil UML face à KerML
  3. Des définitions et des usages au lieu de blocs et de propriétés
  4. Une notation textuelle standard
  5. Bibliothèque standard, grandeurs et unités
  6. Ports, interfaces et connexions
  7. Comportement : actions et états
  8. Exigences et cas de vérification
  9. Des vues au lieu de diagrammes dessinés
  10. La Systems Modeling API et l'échange JSON
  11. Migrer un modèle de SysML v1 vers v2
    1. Ce qui se transpose directement
    2. Ce qui doit être repensé
  12. Comment les listings ont été contrôlés
  13. L'essayer dans Holarch
  14. Pour aller plus loin

En un coup d'œil

Les lecteurs qui connaissent SysML v1 reconnaîtront la plupart des concepts dans SysML v2. Ce qui a changé, c'est la façon dont ils sont construits et la précision avec laquelle ils sont définis. Le tableau résume la comparaison ; chaque ligne a sa propre section ci-dessous.

SujetSysML v1SysML v2
FondementUn profil d'UML 2 : des stéréotypes sur un sous-ensemble des métaclasses UMLSon propre métamodèle fondé sur le Kernel Modeling Language (KerML), avec une sémantique définie dans une bibliothèque formelle
StructureDes blocs avec des propriétés de part, de référence et de valeurDes définitions et des usages pour chaque type d'élément : part def et part, port def et port, etc.
NotationGraphique (neuf types de diagrammes) ; pas de texte standard pour le modèle entierUne notation textuelle standard et une notation graphique standard pour le même modèle
Grandeurs et unitésDes types de valeur avec unités, par un modèle d'unités et des bibliothèques de modèlesLes grandeurs ISQ et les unités SI dans la bibliothèque standard, utilisées directement dans des valeurs comme 6.5 [kg]
InterfacesPorts complets et proxy, blocs d'interface, propriétés de flux, flux d'items sur les connecteursDéfinitions de port avec features orientées, conjugaison ~, définitions d'interface avec extrémités typées, flux et liaison
ComportementActivités, machines à états et interactions issues d'UML, reliées à la structure par l'allocationActions, états et messages en tant qu'occurrences, reliés à la structure par perform et exhibit
ExigencesUne classe stéréotypée avec un identifiant et un texte ; les contraintes se trouvent séparément dans des blocs de contraintesUne exigence est une contrainte avec un sujet ; texte et condition vérifiable dans un seul élément
VérificationDes cas de test liés par verifyDes cas de vérification avec un objectif et un verdict
DiagrammesDes dessins conservés par l'outil ; les dispositions passent rarement d'un outil à l'autreLes vues sont des éléments du modèle qui énoncent ce qu'elles montrent ; l'outil les restitue
ÉchangeDes fichiers XMI, avec des différences entre outilsDes fichiers texte, du JSON et la Systems Modeling API standard

Fondement : un profil UML face à KerML

SysML v1 est défini comme un profil d'UML 2. Il prend un sous-ensemble d'UML et ajoute des stéréotypes : un bloc est une classe UML avec le stéréotype «block», une exigence est une classe avec «requirement», une propriété de flux est une propriété avec «flowProperty». Cela a rendu SysML v1 rapide à adopter, car les outils UML pouvaient l'héberger, mais cela signifiait aussi que les concepts système étaient pliés aux concepts logiciels, et que le sens de nombreuses constructions venait de la sémantique d'UML, écrite pour le logiciel.

SysML v2 abandonne la base UML. Il est construit sur le Kernel Modeling Language (KerML), un langage plus petit dont le noyau reçoit un sens précis dans une bibliothèque de modèles KerML. SysML v2 ajoute par-dessus les concepts de l'ingénierie des systèmes : parts, ports, actions, états, exigences, cas et vues. Chaque construction SysML v2 est définie comme une spécialisation d'un élément de cette bibliothèque. En pratique, cela signifie :

  • La structure et le comportement partagent un même fondement. Les parts et les actions sont toutes deux des occurrences qui existent dans le temps ; une part peut donc réaliser une action ou présenter un état sans couche d'allocation distincte.
  • Les outils s'accordent davantage sur ce que signifie un modèle, car le sens se trouve dans la spécification et ses bibliothèques plutôt que dans l'interprétation de chaque outil.
  • Les stéréotypes ne sont plus le mécanisme d'extension. SysML v2 utilise des définitions de métadonnées pour les annotations propres à un outil ou à un domaine.

Des définitions et des usages au lieu de blocs et de propriétés

En SysML v1, le bloc est l'élément central : un diagramme de définition de blocs définit des blocs, et un diagramme de blocs internes montre les parts d'un bloc. Une propriété de part est typée par un bloc ; une propriété de valeur est typée par un type de valeur. Donner à une part une valeur différente de la valeur par défaut de son bloc, par exemple une pompe plus lourde dans une variante de produit, nécessite un contournement : un bloc spécialisé qui redéfinit la propriété, un type propre à la propriété, ou une spécification d'instance.

SysML v2 généralise cela en un seul schéma pour chaque élément : une définition dit ce qu'est un type de chose, un usage est une telle chose dans un contexte. Les usages s'imbriquent, et un usage imbriqué peut redéfinir ce dont il hérite avec sa propre valeur. Le même schéma vaut pour les attributs, ports, actions, états, exigences et vues.

package CoolingLoop {
  doc /* The engine cooling loop of a small generator set. */

  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  part def Pump {
    attribute mass : MassValue;
    attribute shaftPower : PowerValue;
  }

  part def ElectricPump :> Pump {
    attribute supplyVoltage : ElectricPotentialValue;
  }

  part def Radiator {
    attribute mass : MassValue;
    attribute heatRejection : PowerValue;
  }

  part def CoolingSystem {
    part pump : ElectricPump {
      attribute redefines mass = 2.4 [kg];
      attribute redefines shaftPower = 150 [W];
      attribute redefines supplyVoltage = 24 [V];
    }
    part radiator : Radiator {
      :>> mass = 6.5 [kg];
      :>> heatRejection = 18 [kW];
    }
    attribute totalMass : MassValue = pump.mass + radiator.mass;
  }
}
SysML v1SysML v2 dans ce listing
Bloc Pump avec des propriétés de valeurpart def Pump avec des attributs
Généralisation de ElectricPump vers PumpSpécialisation part def ElectricPump :> Pump
Propriété de part pump de CoolingSystem, typée par le blocUsage de part part pump : ElectricPump
Une valeur propre au contexte via un bloc spécialisé ou une instanceattribute redefines mass = 2.4 [kg] directement sur l'usage
Une valeur dérivée avec un bloc de contraintes et un diagramme paramétriquetotalMass sous forme d'expression sur l'attribut

:>> est la forme courte de redefines. Les propriétés de référence de v1, qui pointent vers une part possédée ailleurs, deviennent des usages ref en v2.

Une notation textuelle standard

SysML v1 n'a pas de forme texte standard pour un modèle entier. Le modèle vit dans le référentiel de l'outil, les gens travaillent dans des diagrammes, et les fichiers circulent entre outils en XMI, qui est destiné aux machines, pas à la lecture. Le texte n'apparaît que ponctuellement : expressions de contraintes, comportements opaques et langages d'action dans certains outils.

SysML v2 dispose d'une notation textuelle qui couvre tout le langage, à côté d'une notation graphique. Les deux montrent le même modèle. Chaque listing de cette page est écrit dans cette notation textuelle ; le tutoriel SysML v2 y construit un modèle complet pas à pas. Le texte change la façon dont une équipe peut travailler :

  • Un modèle peut être revu ligne par ligne, comparé avec un diff et placé sous gestion de versions avec le reste des données d'ingénierie.
  • Les ingénieurs peuvent saisir un modèle rapidement, copier des schémas d'un modèle à l'autre et en générer des parties avec des scripts.
  • Un modèle peut être contrôlé comme du code source : noms non résolus, unités erronées et ports incompatibles sont signalés là où ils se produisent.

La notation textuelle ne remplace pas les diagrammes. Elle fait du modèle l'artefact principal, et les diagrammes en deviennent des vues, comme décrit plus bas.

Bibliothèque standard, grandeurs et unités

SysML v1 type une propriété de valeur par un type de valeur, qui peut porter une unité et une nature de grandeur. La spécification comprend un modèle des grandeurs et des unités, et des bibliothèques de modèles pour les unités courantes, mais les outils diffèrent par les bibliothèques qu'ils fournissent et par le degré auquel ils contrôlent les unités dans les expressions.

SysML v2 fournit une bibliothèque standard qui fait partie du langage. Elle comprend le Système international de grandeurs (ISQ), les unités SI (SI), les unités usuelles américaines, les types scalaires, les collections et les définitions de vues standard. Dans le listing ci-dessus :

  • attribute mass : MassValue indique que l'attribut est une masse, pas un nombre.
  • 6.5 [kg] est une valeur de grandeur : un nombre avec une unité, écrit en ligne.
  • pump.mass + radiator.mass additionne deux masses. Un outil qui évalue les unités peut rejeter une expression qui ajoute une masse à une puissance, ou une masse exprimée en volts.

Ports, interfaces et connexions

Les ports de SysML v1 ont connu plusieurs conceptions. Les premières versions avaient des ports standard et des ports de flux ; les versions ultérieures les ont remplacés par des ports complets, des ports proxy et des blocs d'interface avec des propriétés de flux. Une propriété de flux a un sens (in, out ou inout), un port peut être conjugué pour inverser les sens, et les flux d'items sur les connecteurs disent ce qui circule. De nombreux modèles v1 existants mélangent encore les anciens et les nouveaux types de ports.

SysML v2 conserve les idées et les uniformise. Une définition de port liste des features orientées, le côté récepteur utilise le conjugué ~ de la même définition, et une définition d'interface décrit un type de connexion avec des extrémités typées.

package CoolantInterfaces {
  private import ISQ::*;

  item def Coolant {
    attribute temperature : ThermodynamicTemperatureValue;
  }

  port def CoolantPort {
    out item coolant : Coolant;
  }

  interface def Hose {
    end supply : CoolantPort;
    end ret : ~CoolantPort;
  }

  part def Pump {
    port outlet : CoolantPort;
  }

  part def Radiator {
    port inlet : ~CoolantPort;
  }

  part def Loop {
    part pump : Pump;
    part radiator : Radiator;
    interface hose : Hose connect pump.outlet to radiator.inlet;
  }
}
SysML v1SysML v2
Bloc d'interface avec propriétés de fluxport def avec des features in, out ou inout
Port proxy ou complet typé par le bloc d'interfaceUsage port typé par la définition de port
Type de port conjugué~CoolantPort
Connecteur, éventuellement typé par un bloc d'associationconnect … to …, ou un usage interface typé par une interface def
Connecteur de liaisonbind a = b
Flux d'item sur un connecteurUsage flow, ou une feature item du port

Comme les sens font partie des définitions, un vérificateur peut avertir quand les deux extrémités d'une connexion émettent la même feature et qu'aucune ne la reçoit.

Le Loop du listing dans une vue d'interconnexion, l'équivalent SysML v2 d'un diagramme de blocs internes.

Comportement : actions et états

SysML v1 emprunte son comportement à UML : activités avec une sémantique de flux de jetons, machines à états et interactions pour les diagrammes de séquence. Un comportement est relié à la structure qui le réalise par l'allocation, souvent avec des partitions d'activité (couloirs) ou des relations «allocate».

En SysML v2, les actions et les états sont des occurrences, comme les parts. Une définition d'action a des paramètres d'entrée et de sortie ; les successions (first … then …) donnent l'ordre et les flux disent ce qui passe entre les étapes. Une définition d'état a des états et des transitions avec déclencheurs, gardes et effets. Une part réalise une action (perform) et présente un état (exhibit) ; le lien avec la structure fait donc partie du langage au lieu d'être une relation ajoutée.

package PumpBehavior {
  private import ISQ::*;

  item def StartCommand;
  item def StopCommand;
  item def Coolant;

  action def Circulate {
    in item cold : Coolant;
    out item warm : Coolant;
  }

  action def CoolEngine {
    action pumpCoolant : Circulate;
    action rejectHeat : Circulate;
    flow pumpCoolant.warm to rejectHeat.cold;
    first start then pumpCoolant;
    first pumpCoolant then rejectHeat;
    first rejectHeat then done;
  }

  state def PumpModes {
    entry; then off;
    state off;
    state running;
    transition first off accept StartCommand then running;
    transition first running accept StopCommand then off;
  }

  part def Pump {
    exhibit state modes : PumpModes;
  }
}
SysML v1SysML v2
Activité avec actions, flux de contrôle et flux d'objetsaction def avec des usages d'action, des successions et des flow
Nœuds de bifurcation, de réunion, de décision et de fusionfork, join, decide et merge
Action d'appel de comportementUn usage d'action typé par une autre définition d'action
Partition ou «allocate» de l'activité vers le blocperform dans la part
Machine à états possédée par un blocstate def, avec exhibit state dans la part
Transition avec déclencheur, garde et effettransition … accept … if … do … then …
Interaction (diagramme de séquence)Occurrences avec des message, affichées dans une vue de séquence
PumpModes dans une vue des transitions d'état, dessinée à partir du texte ci-dessus.

Exigences et cas de vérification

Une exigence SysML v1 est une classe stéréotypée avec deux chaînes : un identifiant et un texte. Des relations la relient au reste du modèle : satisfy, verify, derive, refine, trace et copy. Un cas de test est un comportement marqué «testCase». Contrôler une exigence chiffrée nécessite un bloc de contraintes distinct dans un diagramme paramétrique, et rien dans le langage ne relie cette contrainte au texte de l'exigence.

En SysML v2, une définition d'exigence est un type de définition de contrainte. Elle a un sujet (ce sur quoi porte l'exigence), peut avoir des attributs comme une limite, et contient la condition qui doit être vérifiée. Le texte doc et la condition se trouvent dans un même élément. Un cas de vérification énonce dans son objectif l'exigence qu'il vérifie et renvoie un verdict.

package CoolingRequirements {
  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  part def CoolingSystem {
    attribute heatRejection : PowerValue;
  }

  part cooling : CoolingSystem {
    attribute redefines heatRejection = 18 [kW];
  }

  requirement def <'CR-1'> HeatRejection {
    doc /* The cooling system shall reject at least the engine's waste heat at full load. */
    subject system : CoolingSystem;
    attribute wasteHeat : PowerValue;
    require constraint { system.heatRejection >= wasteHeat }
  }

  requirement coolingSpec : HeatRejection {
    subject system : CoolingSystem;
    attribute redefines wasteHeat = 15 [kW];
  }

  satisfy coolingSpec by cooling;

  verification def <'VC-1'> HeatRunTest {
    doc /* Run the engine at full load on a test stand and measure the heat the radiator rejects. */
    subject system : CoolingSystem;
    objective {
      verify coolingSpec;
    }
    return verdict : Boolean = system.heatRejection >= coolingSpec.wasteHeat;
  }

  verification heatRun : HeatRunTest {
    subject system = cooling;
  }
}
  • <'CR-1'> est un nom court, l'emplacement en v2 de l'identifiant d'exigence de v1.
  • require constraint est la forme vérifiable du texte. Avec 18 kW contre 15 kW, un outil qui évalue les contraintes signale l'exigence comme satisfaite.
  • satisfy et verify conservent leur sens de v1. Derive, refine et trace correspondent à des dépendances ou à des usages d'exigence imbriqués dans d'autres exigences ; les équipes décident de la façon de les modéliser.
  • SysML v2 ajoute aux exigences les hypothèses (assume constraint), les parties prenantes et les préoccupations, et les cas d'utilisation et cas d'analyse à côté des cas de vérification.

Des vues au lieu de diagrammes dessinés

Un diagramme SysML v1 est un dessin détenu par l'outil : quelqu'un choisit quels éléments apparaissent et où. Deux diagrammes du même bloc peuvent ne pas s'accorder sur ce qu'il contient, et les dispositions de diagrammes survivent rarement à un échange entre outils. Les versions ultérieures de v1 ont ajouté les vues et les points de vue, mais ils servent surtout aux documents, pas aux diagrammes que les ingénieurs dessinent chaque jour.

En SysML v2, une vue est un élément du modèle. Elle nomme ce qu'il faut montrer avec expose, les types d'éléments à inclure avec filter, et la définition de vue standard selon laquelle la restituer. La disposition est laissée à l'outil ; le contenu de la vue se trouve dans le modèle et peut être lu dans le texte.

package CoolingViews {
  private import StandardViewDefinitions::*;

  part def Pump;
  part def Radiator;

  part def Loop {
    part pump : Pump;
    part radiator : Radiator;
    connect pump to radiator;
  }

  view loopConnections : InterconnectionView {
    expose Loop;
  }

  view structure : GeneralView {
    filter @SysML::PartDefinition;
    expose CoolingViews::*;
  }
}
Diagramme SysML v1Vue SysML v2
Diagramme de définition de blocs, de packages, d'exigencesVue générale, avec filtres
Diagramme de blocs internesVue d'interconnexion
Diagramme d'activitéVue de flux d'Action
Diagramme de machine à étatsVue des transitions d'état
Diagramme de séquenceVue de séquence
Diagramme paramétriqueVue générale ou vue d'interconnexion des contraintes et de leurs liaisons
Diagramme de cas d'utilisationVue générale des cas d'utilisation et des acteurs
Tableaux et matrices (propres à chaque outil en v1)Vue grille

La Systems Modeling API et l'échange JSON

Les modèles SysML v1 circulent entre outils en XMI. XMI est un standard, mais chaque outil écrit sa propre variante, ses stéréotypes et ses données de diagramme ; un échange doit donc généralement être testé pour chaque paire d'outils, et il n'existe pas de moyen standard pour qu'un programme interroge un modèle détenu par un autre outil.

SysML v2 est accompagné de la spécification Systems Modeling API and Services. Elle définit des services pour les projets, les branches, les commits, les éléments et les requêtes, et une liaison REST/HTTP dans laquelle chaque élément est un objet JSON avec un @id et un @type. Les conséquences :

  • Un script, un tableau de bord ou un autre outil peut lire et interroger un modèle par une interface documentée unique au lieu d'une interface propre à un éditeur.
  • Les identifiants des éléments voyagent avec le modèle ; les liens entre outils peuvent donc survivre à un échange.
  • Les modèles sont versionnés sous forme de commits sur des branches, un peu comme du code source.

Les fichiers texte et le JSON se complètent : le texte sert à la lecture, à la revue et au diff par des personnes ; le JSON conserve les identifiants sur lesquels s'appuient les outils.

Migrer un modèle de SysML v1 vers v2

Faire passer un modèle v1 en v2 est une traduction entre langages, pas une mise à niveau de fichier, et l'outil cible détermine la part automatisée : ce qu'il faut vérifier dans un outil SysML v2 traite l'import v1 parmi les autres contrôles. Une grande partie d'un modèle typique se transpose directement, et une partie gagne à être reconstruite à la manière de v2 plutôt que traduite littéralement.

Ce qui se transpose directement

  • Les packages et leur imbrication.
  • Les blocs en définitions de part, les propriétés de part en usages de part, les propriétés de référence en usages ref, les généralisations en spécialisations.
  • Les propriétés de valeur en attributs, avec grandeurs et unités lorsque les types de valeur v1 avaient des unités.
  • Les blocs d'interface avec propriétés de flux en définitions de port ; les ports proxy et complets en usages de port ; les connecteurs en connexions ou en interfaces.
  • Les identifiants et textes d'exigences en noms courts et doc ; les relations satisfy et verify.
  • Les machines à états en définitions d'état ; les activités bien structurées en définitions d'action avec successions et flux.

Ce qui doit être repensé

  • Valeurs propres au contexte. Les types propres à une propriété, les spécifications d'instance et les redéfinitions créées uniquement pour fixer une valeur deviennent de simples redéfinitions sur des usages. Une traduction littérale conserve le contournement.
  • Exigences purement textuelles. v2 les autorise, mais le gain vient de l'ajout de la condition. Décidez quelles exigences reçoivent une require constraint.
  • Blocs de contraintes et diagrammes paramétriques. Ils deviennent des définitions de contrainte et de calcul, souvent écrites sous forme d'expressions directement sur les attributs, comme totalMass ci-dessus.
  • Allocation. Les partitions d'activité et les relations «allocate» du comportement vers la structure deviennent perform et exhibit lorsque le sens est « cette part fait ceci ».
  • Anciens types de ports. Les ports standard et les ports de flux des premiers modèles v1 demandent le plus de travail, car v2 n'a qu'un seul concept de port.
  • Profils et stéréotypes. Les stéréotypes personnalisés et les valeurs étiquetées deviennent des définitions de métadonnées ; leur sens doit être conçu de nouveau.
  • Diagrammes. Les dispositions ne sont pas reprises. Chaque diagramme qui compte devient une vue, et son contenu est réexprimé avec expose et filter.
  • Comportements opaques et scripts d'outils. Le code écrit dans un langage d'action ou dans le langage de script d'un outil ne se traduit pas ; il doit être réécrit ou conservé hors du modèle.

Planifiez une migration comme toute modification de modèle : convertissez d'abord un package représentatif, revoyez-le avec les utilisateurs du modèle, arrêtez les conventions de modélisation pour les points ci-dessus, puis convertissez le reste. Conservez le modèle v1 comme référence jusqu'à ce que le modèle v2 ait été revu. Faire passer un modèle SysML v1 en SysML v2 parcourt ces étapes.

Comment les listings ont été contrôlés

Chaque listing de cette page a été analysé et contrôlé avec le Holarch Language Engine, le moteur de l'Éditeur SysML v2 de Holarch, avec la bibliothèque standard SysML v2 chargée, et ne produit ni erreur ni avertissement. Pour les constructions SysML v2 que le moteur prend en charge et ses lacunes connues, voir couverture du langage SysML v2. Pour un modèle détaillé plus long, voir le tutoriel SysML v2.

L'essayer dans Holarch

Holarch propose des projets SysML v2, où la notation textuelle et les vues modifient un seul modèle, et des projets LML. Pour lire les listings ci-dessus comme un modèle :

  1. Créez un projet SysML v2. Voir démarrer avec les projets SysML v2.
  2. Dans Modèle → Éditeur, cliquez sur + Nouveau package et collez un listing. Le texte qui s'analyse correctement est appliqué après une courte pause, et les problèmes sont signalés sur place. Voir l'Éditeur.
  3. Ouvrez la liste Diagrammes pour voir les vues. Voir la référence des vues.

Modèles SysML v1. Un projet SysML v2 importe directement un modèle SysML 1.x : dans Modèle → Importer et exporter, déposez un fichier XMI (de Cameo Systems Modeler ou MagicDraw, Enterprise Architect, Rhapsody ou Papyrus) ou un projet Cameo ou MagicDraw .mdzip. Holarch le convertit en texte SysML v2, contrôle le texte et affiche un rapport de conversion qui classe chaque élément comme converti, approché ou laissé de côté, avec le motif, avant toute modification. Les dispositions de diagrammes ne sont pas converties ; considérez donc le résultat comme un point de départ pour le travail de réflexion décrit ci-dessus, pas comme une migration terminée. Voir importer des modèles SysML v1.

Les projets LML importent aussi le XMI SysML 1.x, et exportent de nouveau le modèle en XMI SysML 1.6 ou en fichier Papyrus .uml ; un fichier modifié dans Papyrus se réimporte dans le même projet et met à jour les éléments sur place d'après leur identifiant XMI. Voir importer un modèle UML/SysML et aller-retour avec Papyrus.

Pour aller plus loin