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
- En un coup d'œil
- Fondement : un profil UML face à KerML
- Des définitions et des usages au lieu de blocs et de propriétés
- Une notation textuelle standard
- Bibliothèque standard, grandeurs et unités
- Ports, interfaces et connexions
- Comportement : actions et états
- Exigences et cas de vérification
- Des vues au lieu de diagrammes dessinés
- La Systems Modeling API et l'échange JSON
- Migrer un modèle de SysML v1 vers v2
- Comment les listings ont été contrôlés
- L'essayer dans Holarch
- 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.
| Sujet | SysML v1 | SysML v2 |
|---|---|---|
| Fondement | Un profil d'UML 2 : des stéréotypes sur un sous-ensemble des métaclasses UML | Son propre métamodèle fondé sur le Kernel Modeling Language (KerML), avec une sémantique définie dans une bibliothèque formelle |
| Structure | Des blocs avec des propriétés de part, de référence et de valeur | Des définitions et des usages pour chaque type d'élément : part def et part, port def et port, etc. |
| Notation | Graphique (neuf types de diagrammes) ; pas de texte standard pour le modèle entier | Une notation textuelle standard et une notation graphique standard pour le même modèle |
| Grandeurs et unités | Des types de valeur avec unités, par un modèle d'unités et des bibliothèques de modèles | Les grandeurs ISQ et les unités SI dans la bibliothèque standard, utilisées directement dans des valeurs comme 6.5 [kg] |
| Interfaces | Ports complets et proxy, blocs d'interface, propriétés de flux, flux d'items sur les connecteurs | Définitions de port avec features orientées, conjugaison ~, définitions d'interface avec extrémités typées, flux et liaison |
| Comportement | Activités, machines à états et interactions issues d'UML, reliées à la structure par l'allocation | Actions, états et messages en tant qu'occurrences, reliés à la structure par perform et exhibit |
| Exigences | Une classe stéréotypée avec un identifiant et un texte ; les contraintes se trouvent séparément dans des blocs de contraintes | Une exigence est une contrainte avec un sujet ; texte et condition vérifiable dans un seul élément |
| Vérification | Des cas de test liés par verify | Des cas de vérification avec un objectif et un verdict |
| Diagrammes | Des dessins conservés par l'outil ; les dispositions passent rarement d'un outil à l'autre | Les vues sont des éléments du modèle qui énoncent ce qu'elles montrent ; l'outil les restitue |
| Échange | Des fichiers XMI, avec des différences entre outils | Des 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 v1 | SysML v2 dans ce listing |
|---|---|
Bloc Pump avec des propriétés de valeur | part def Pump avec des attributs |
Généralisation de ElectricPump vers Pump | Spécialisation part def ElectricPump :> Pump |
Propriété de part pump de CoolingSystem, typée par le bloc | Usage de part part pump : ElectricPump |
| Une valeur propre au contexte via un bloc spécialisé ou une instance | attribute redefines mass = 2.4 [kg] directement sur l'usage |
| Une valeur dérivée avec un bloc de contraintes et un diagramme paramétrique | totalMass 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 : MassValueindique 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.massadditionne 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 v1 | SysML v2 |
|---|---|
| Bloc d'interface avec propriétés de flux | port def avec des features in, out ou inout |
| Port proxy ou complet typé par le bloc d'interface | Usage port typé par la définition de port |
| Type de port conjugué | ~CoolantPort |
| Connecteur, éventuellement typé par un bloc d'association | connect … to …, ou un usage interface typé par une interface def |
| Connecteur de liaison | bind a = b |
| Flux d'item sur un connecteur | Usage 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.
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 v1 | SysML v2 |
|---|---|
| Activité avec actions, flux de contrôle et flux d'objets | action def avec des usages d'action, des successions et des flow |
| Nœuds de bifurcation, de réunion, de décision et de fusion | fork, join, decide et merge |
| Action d'appel de comportement | Un usage d'action typé par une autre définition d'action |
| Partition ou «allocate» de l'activité vers le bloc | perform dans la part |
| Machine à états possédée par un bloc | state def, avec exhibit state dans la part |
| Transition avec déclencheur, garde et effet | transition … 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 constraintest la forme vérifiable du texte. Avec 18 kW contre 15 kW, un outil qui évalue les contraintes signale l'exigence comme satisfaite.satisfyetverifyconservent 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 v1 | Vue SysML v2 |
|---|---|
| Diagramme de définition de blocs, de packages, d'exigences | Vue générale, avec filtres |
| Diagramme de blocs internes | Vue d'interconnexion |
| Diagramme d'activité | Vue de flux d'Action |
| Diagramme de machine à états | Vue des transitions d'état |
| Diagramme de séquence | Vue de séquence |
| Diagramme paramétrique | Vue générale ou vue d'interconnexion des contraintes et de leurs liaisons |
| Diagramme de cas d'utilisation | Vue 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
totalMassci-dessus. - Allocation. Les partitions d'activité et les relations «allocate» du comportement vers la structure deviennent
performetexhibitlorsque 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
exposeetfilter. - 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 :
- Créez un projet SysML v2. Voir démarrer avec les projets SysML v2.
- 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.
- 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
- Tutoriel SysML v2 : construire un petit système pas à pas dans la notation textuelle.
- Outils SysML v2 : ce qu'il faut vérifier avant d'en choisir un : une liste de contrôle et un modèle de test pour tout outil candidat.
- Les projets SysML v2 dans Holarch : texte, vues et pages d'ingénierie sur un seul modèle.
- Couverture du langage SysML v2 : ce que le moteur prend en charge et ses lacunes connues.
- Échanger des modèles SysML v2 : texte, JSON et référentiels Systems Modeling API.