Guida · SysML v2
SysML v1 e v2: in che cosa differiscono i due linguaggi
Ascolta questa guida 20 min
SysML v1 e SysML v2 hanno lo stesso scopo e molti nomi in comune, ma SysML v2 è un nuovo linguaggio più che una revisione. Questa guida confronta i due fianco a fianco: il fondamento, definizioni e usi, la notazione testuale, le unità, le porte, il comportamento, i requisiti, le viste, l’API e che cosa comporta una migrazione da v1 a v2.
In questa pagina
- In sintesi
- Fondamento: un profilo UML contro KerML
- Definizioni e usi invece di blocchi e proprietà
- Una notazione testuale standard
- Libreria standard, grandezze e unità
- Porte, interfacce e connessioni
- Comportamento: azioni e stati
- Requisiti e casi di verifica
- Viste invece di diagrammi disegnati
- La Systems Modeling API e lo scambio in JSON
- Migrare un modello da SysML v1 a v2
- Come sono stati controllati i listati
- Provarlo in Holarch
- Dove andare dopo
In sintesi
Chi conosce SysML v1 riconoscerà la maggior parte dei concetti in SysML v2. È cambiato il modo in cui sono costruiti e la precisione con cui sono definiti. La tabella riassume il confronto; ogni riga ha una propria sezione più avanti.
| Argomento | SysML v1 | SysML v2 |
|---|---|---|
| Fondamento | Un profilo di UML 2: stereotipi su un sottoinsieme delle metaclassi UML | Un proprio metamodello basato sul Kernel Modeling Language (KerML), con una semantica definita in una libreria formale |
| Struttura | Blocchi con part, reference e value property | Definizioni e usi per ogni tipo di elemento: part def e part, port def e port, e così via |
| Notazione | Grafica (nove tipi di diagramma); nessun testo standard per l’intero modello | Una notazione testuale standard e una notazione grafica standard per lo stesso modello |
| Grandezze e unità | Value type con unità, tramite un modello di unità e librerie di modelli | Grandezze ISQ e unità SI nella libreria standard, usate direttamente nei valori come 6.5 [kg] |
| Interfacce | Full port e proxy port, interface block, flow property, item flow sui connettori | Definizioni di porta con feature orientate, coniugazione ~, definizioni di interfaccia con estremi tipizzati, flussi e binding |
| Comportamento | Attività, macchine a stati e interazioni da UML, collegate alla struttura tramite allocazione | Azioni, stati e messaggi come occorrenze, collegati alla struttura tramite perform ed exhibit |
| Requisiti | Una classe stereotipata con un id e un testo; i vincoli si trovano separatamente nei constraint block | Un requisito è un vincolo con un soggetto; testo e condizione verificabile in un unico elemento |
| Verifica | Casi di test collegati tramite verify | Casi di verifica con un obiettivo e un verdetto |
| Diagrammi | Disegni conservati dallo strumento; i layout passano raramente da uno strumento all’altro | Le viste sono elementi del modello che dichiarano che cosa mostrano; lo strumento le visualizza |
| Scambio | File XMI, con differenze tra gli strumenti | File di testo, JSON e la Systems Modeling API standard |
Fondamento: un profilo UML contro KerML
SysML v1 è definito come profilo di UML 2. Prende un sottoinsieme di UML e aggiunge stereotipi: un blocco è una classe UML con lo stereotipo «block», un requisito è una classe con «requirement», una flow property è una proprietà con «flowProperty». Questo ha reso SysML v1 rapido da adottare, perché gli strumenti UML potevano ospitarlo, ma ha anche significato piegare i concetti dei sistemi ai concetti del software, e che il significato di molti costrutti derivasse dalla semantica di UML, scritta per il software.
SysML v2 abbandona la base UML. È costruito sul Kernel Modeling Language (KerML), un linguaggio più piccolo il cui nucleo riceve un significato preciso in una libreria di modelli KerML. SysML v2 aggiunge sopra i concetti dell’ingegneria dei sistemi: parti, porte, azioni, stati, requisiti, casi e viste. Ogni costrutto SysML v2 è definito come specializzazione di qualcosa in quella libreria. In pratica ciò significa che:
- Struttura e comportamento condividono un unico fondamento. Parti e azioni sono entrambe occorrenze che esistono nel tempo, quindi una parte può eseguire un’azione o manifestare uno stato senza un livello di allocazione separato.
- Gli strumenti concordano più strettamente sul significato di un modello, perché il significato si trova nella specifica e nelle sue librerie anziché nell’interpretazione di ciascuno strumento.
- Gli stereotipi non sono più il meccanismo di estensione. SysML v2 usa definizioni di metadati per le annotazioni specifiche di uno strumento o di un dominio.
Definizioni e usi invece di blocchi e proprietà
In SysML v1 il blocco è l’elemento centrale: un block definition diagram definisce i blocchi, e un internal block diagram mostra le parti di un blocco. Una part property è tipizzata da un blocco; una value property è tipizzata da un value type. Dare a una parte un valore diverso da quello predefinito del suo blocco, per esempio una pompa più pesante in una variante di prodotto, richiede un espediente: un blocco specializzato che ridefinisce la proprietà, un tipo specifico di proprietà o una instance specification.
SysML v2 generalizza tutto questo in un unico schema per ogni elemento: una definizione dice che cos’è un tipo di cosa, un uso è una tale cosa in un contesto. Gli usi si annidano, e un uso annidato può ridefinire ciò che eredita con un proprio valore. Lo stesso schema vale per attributi, porte, azioni, stati, requisiti e viste.
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 in questo listato |
|---|---|
Blocco Pump con value property | part def Pump con attributi |
Generalizzazione da ElectricPump a Pump | Specializzazione part def ElectricPump :> Pump |
Part property pump di CoolingSystem, tipizzata dal blocco | Uso di parte part pump : ElectricPump |
| Un valore specifico del contesto tramite un blocco specializzato o un’istanza | attribute redefines mass = 2.4 [kg] direttamente sull’uso |
| Un valore derivato con un constraint block e un diagramma parametrico | totalMass come espressione sull’attributo |
:>> è la forma breve di redefines. Le reference property di v1, che puntano a una parte posseduta altrove, diventano usi ref in v2.
Una notazione testuale standard
SysML v1 non ha una forma testuale standard per un intero modello. Il modello risiede nel repository dello strumento, le persone lavorano nei diagrammi e i file passano da uno strumento all’altro come XMI, pensato per le macchine, non per la lettura. Il testo compare solo in alcuni punti: espressioni di vincolo, comportamenti opachi e linguaggi di azioni in alcuni strumenti.
SysML v2 ha una notazione testuale che copre l’intero linguaggio, accanto a una notazione grafica. Entrambe mostrano lo stesso modello. Ogni listato di questa pagina è in quella notazione testuale; il tutorial di SysML v2 vi costruisce un modello completo passo per passo. Il testo cambia il modo in cui un team può lavorare:
- Un modello si può rivedere riga per riga, confrontare con un diff e tenere sotto controllo di versione insieme al resto dei dati di ingegneria.
- Gli ingegneri possono digitare un modello rapidamente, copiare schemi tra modelli e generarne parti con script.
- Un modello si può controllare come il codice sorgente: nomi non risolti, unità errate e porte non corrispondenti vengono segnalati nel punto in cui si trovano.
La notazione testuale non sostituisce i diagrammi. Fa del modello l’artefatto principale, e i diagrammi ne diventano viste, come descritto più avanti.
Libreria standard, grandezze e unità
SysML v1 tipizza una value property con un value type, che può avere un’unità e un tipo di grandezza. La specifica comprende un modello per grandezze e unità e librerie di modelli per le unità comuni, ma gli strumenti differiscono per le librerie fornite e per quanto controllano le unità nelle espressioni.
SysML v2 fornisce una libreria standard come parte del linguaggio. Comprende il Sistema internazionale delle grandezze (ISQ), le unità SI (SI), le unità consuetudinarie statunitensi, i tipi scalari, le collezioni e le definizioni di vista standard. Nel listato qui sopra:
attribute mass : MassValuedice che l’attributo è una massa, non un numero.6.5 [kg]è un valore di grandezza: un numero con un’unità, scritto in linea.pump.mass + radiator.masssomma due masse. Uno strumento che valuta le unità può rifiutare un’espressione che somma una massa a una potenza, o una massa espressa in volt.
Porte, interfacce e connessioni
Le porte di SysML v1 hanno attraversato diverse progettazioni. Le prime versioni avevano standard port e flow port; le versioni successive le hanno sostituite con full port, proxy port e interface block con flow property. Una flow property ha una direzione (in, out o inout), una porta può essere coniugata per invertire le direzioni, e gli item flow sui connettori dicono che cosa si muove. Molti modelli v1 esistenti mescolano ancora i tipi di porta vecchi e nuovi.
SysML v2 conserva le idee e le rende uniformi. Una definizione di porta elenca feature orientate, il lato ricevente usa il coniugato ~ della stessa definizione, e una definizione di interfaccia descrive un tipo di connessione con estremi tipizzati.
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 |
|---|---|
| Interface block con flow property | port def con feature in, out o inout |
| Proxy port o full port tipizzata dall’interface block | Uso port tipizzato dalla definizione di porta |
| Tipo di porta coniugato | ~CoolantPort |
| Connettore, eventualmente tipizzato da un association block | connect … to …, oppure un uso interface tipizzato da una interface def |
| Binding connector | bind a = b |
| Item flow su un connettore | Uso flow, oppure una item feature della porta |
Poiché le direzioni fanno parte delle definizioni, un verificatore può avvisare quando entrambi gli estremi di una connessione inviano la stessa feature e nessuno dei due la riceve.
Loop del listato in una Vista di interconnessione, il corrispondente SysML v2 di un internal block diagram.Comportamento: azioni e stati
SysML v1 prende in prestito il comportamento da UML: attività con semantica a flusso di token, macchine a stati e interazioni per i diagrammi di sequenza. Un comportamento è collegato alla struttura che lo esegue tramite allocazione, spesso con partizioni di attività (swim lane) o relazioni «allocate».
In SysML v2 azioni e stati sono occorrenze, come le parti. Una definizione di azione ha parametri di ingresso e di uscita; le successioni (first … then …) danno l’ordine e i flussi dicono che cosa passa tra i passi. Una definizione di stato ha stati e transizioni con trigger, guardie ed effetti. Una parte esegue (perform) un’azione e manifesta (exhibit) uno stato, quindi il collegamento alla struttura fa parte del linguaggio anziché essere una relazione aggiunta.
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 |
|---|---|
| Attività con azioni, flussi di controllo e flussi di oggetti | action def con usi di azione, successioni e flow |
| Nodi fork, join, decision e merge | fork, join, decide e merge |
| Call behavior action | Un uso di azione tipizzato da un’altra definizione di azione |
| Partizione o «allocate» dall’attività al blocco | perform nella parte |
| Macchina a stati posseduta da un blocco | state def, con exhibit state nella parte |
| Transizione con trigger, guardia ed effetto | transition … accept … if … do … then … |
| Interazione (diagramma di sequenza) | Occorrenze con message, mostrate in una Vista di sequenza |
PumpModes in una Vista di transizione di stato, disegnata dal testo qui sopra.Requisiti e casi di verifica
Un requisito SysML v1 è una classe stereotipata con due stringhe: un id e un testo. Le relazioni lo collegano al resto del modello: satisfy, verify, derive, refine, trace e copy. Un caso di test è un comportamento contrassegnato «testCase». Controllare un requisito con dei numeri richiede un constraint block separato in un diagramma parametrico, e nulla nel linguaggio lega quel vincolo al testo del requisito.
In SysML v2 una definizione di requisito è un tipo di definizione di vincolo. Ha un soggetto (ciò di cui tratta il requisito), può avere attributi come un limite e contiene la condizione che deve valere. Il testo doc e la condizione stanno in un unico elemento. Un caso di verifica indica nel suo obiettivo il requisito che verifica e restituisce un verdetto.
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'>è un nome breve, la sede in v2 dell’id del requisito v1.require constraintè la forma verificabile del testo. Con 18 kW contro 15 kW, uno strumento che valuta i vincoli segnala il requisito come soddisfatto.satisfyeverifymantengono il loro significato v1. Derive, refine e trace corrispondono a dipendenze o a usi di requisito annidati in altri requisiti; sono i team a decidere come modellarli.- SysML v2 aggiunge ai requisiti le ipotesi (
assume constraint), gli stakeholder e le concern, e i casi d’uso e i casi di analisi accanto ai casi di verifica.
Viste invece di diagrammi disegnati
Un diagramma SysML v1 è un disegno posseduto dallo strumento: qualcuno sceglie quali elementi compaiono e dove. Due diagrammi dello stesso blocco possono non concordare su ciò che contiene, e i layout dei diagrammi sopravvivono raramente a uno scambio tra strumenti. Le versioni successive di v1 hanno aggiunto viste e viewpoint, ma sono usati soprattutto per i documenti, non per i diagrammi che gli ingegneri disegnano ogni giorno.
In SysML v2 una vista è un elemento del modello. Indica che cosa mostrare con expose, quali tipi di elemento includere con filter e con quale definizione di vista standard visualizzarla. Il layout è lasciato allo strumento; ciò che la vista contiene si trova nel modello e si può leggere nel testo.
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::*;
}
}
| Diagramma SysML v1 | Vista SysML v2 |
|---|---|
| Block definition diagram, package diagram, requirement diagram | Vista generale, con filtri |
| Internal block diagram | Vista di interconnessione |
| Activity diagram | Action Flow View |
| State machine diagram | Vista di transizione di stato |
| Sequence diagram | Vista di sequenza |
| Parametric diagram | Vista generale o di interconnessione dei vincoli e dei loro binding |
| Use case diagram | Vista generale di casi d’uso e attori |
| Tabelle e matrici (specifiche dello strumento in v1) | Vista a griglia |
La Systems Modeling API e lo scambio in JSON
I modelli SysML v1 passano da uno strumento all’altro come XMI. XMI è uno standard, ma ogni strumento scrive una propria variante, propri stereotipi e propri dati dei diagrammi, quindi uno scambio richiede di solito un test per ogni coppia di strumenti, e non esiste un modo standard con cui un programma possa interrogare un modello conservato in un altro strumento.
SysML v2 è accompagnato dalla specifica Systems Modeling API and Services. Definisce servizi per progetti, rami, commit, elementi e query, e un binding REST/HTTP in cui ogni elemento è un oggetto JSON con un @id e un @type. Le conseguenze:
- Uno script, una dashboard o un altro strumento può leggere e interrogare un modello tramite un’unica interfaccia documentata invece di una specifica del fornitore.
- Gli id degli elementi viaggiano con il modello, quindi i collegamenti tra strumenti possono sopravvivere a uno scambio.
- I modelli sono versionati come commit su rami, in modo molto simile al codice sorgente.
File di testo e JSON si completano a vicenda: il testo serve alle persone per leggere, rivedere e confrontare; il JSON conserva gli id su cui contano gli strumenti.
Migrare un modello da SysML v1 a v2
Spostare un modello v1 in v2 è una traduzione tra linguaggi, non un aggiornamento di file, ed è lo strumento di destinazione a decidere quanta parte sia automatizzata: che cosa controllare in uno strumento SysML v2 tratta l’importazione v1 insieme agli altri controlli. Gran parte di un modello tipico si mappa direttamente, e una parte è meglio ricostruirla secondo l’approccio v2 piuttosto che tradurla alla lettera.
Che cosa si mappa senza problemi
- I pacchetti e il loro annidamento.
- Blocchi in definizioni di parte, part property in usi di parte, reference property in usi
ref, generalizzazioni in specializzazioni. - Value property in attributi, con grandezze e unità quando i value type v1 avevano unità.
- Interface block con flow property in definizioni di porta; proxy port e full port in usi di porta; connettori in connessioni o interfacce.
- Id e testo dei requisiti in nomi brevi e
doc; relazioni satisfy e verify. - Macchine a stati in definizioni di stato; attività ben strutturate in definizioni di azione con successioni e flussi.
Che cosa va ripensato
- Valori specifici del contesto. Tipi specifici di proprietà, instance specification e ridefinizioni create solo per impostare un valore diventano semplici ridefinizioni sugli usi. Una traduzione letterale conserva l’espediente.
- Requisiti solo testuali. v2 li consente, ma il vantaggio viene dall’aggiunta della condizione. Decidere quali requisiti ricevono un
require constraint. - Constraint block e diagrammi parametrici. Diventano definizioni di vincolo e di calcolo, spesso scritte come espressioni direttamente sugli attributi, come
totalMassqui sopra. - Allocazione. Le partizioni di attività e le relazioni «allocate» dal comportamento alla struttura diventano
performedexhibitdove il significato è «questa parte fa questo». - Tipi di porta più vecchi. Le standard port e flow port dei primi modelli v1 richiedono il lavoro maggiore, perché v2 ha un solo concetto di porta.
- Profili e stereotipi. Stereotipi personalizzati e tagged value diventano definizioni di metadati; il loro significato va riprogettato.
- Diagrammi. I layout non vengono trasferiti. Ogni diagramma importante diventa una vista, e il suo contenuto viene riformulato con
exposeefilter. - Comportamenti opachi e script degli strumenti. Il codice in un linguaggio di azioni o negli script di uno strumento non si traduce; va riscritto o tenuto fuori dal modello.
Pianificare una migrazione come qualsiasi modifica al modello: convertire prima un pacchetto rappresentativo, rivederlo con le persone che usano il modello, definire gli schemi di modellazione per i punti precedenti, poi convertire il resto. Mantenere il modello v1 come riferimento finché il modello v2 non è stato rivisto. Spostare un modello SysML v1 in SysML v2 illustra questi passi.
Come sono stati controllati i listati
Ogni listato di questa pagina è stato analizzato e controllato con l’Holarch Language Engine, il motore dell’Editor SysML v2 di Holarch, con la libreria standard SysML v2 caricata, e non produce errori né avvisi. Per sapere quali costrutti SysML v2 il motore supporta e quali sono le sue lacune note, si veda Copertura del linguaggio SysML v2. Per un modello svolto più ampio, si veda il tutorial di SysML v2.
Provarlo in Holarch
Holarch offre progetti SysML v2, in cui la notazione testuale e le viste modificano un unico modello, e progetti LML. Per leggere i listati qui sopra come modello:
- Creare un progetto SysML v2. Si veda primi passi con i progetti SysML v2.
- In Modello → Editor, fare clic su + Nuovo package e incollare un listato. Il testo analizzato correttamente viene applicato dopo una breve pausa, e i problemi sono segnalati sul posto. Si veda l’Editor.
- Aprire l’elenco Diagrammi per vedere le viste. Si veda il riferimento sulle viste.
Modelli SysML v1. Un progetto SysML v2 importa direttamente un modello SysML 1.x: in Modello → Importazione ed esportazione, trascinare un file XMI (da Cameo Systems Modeler o MagicDraw, Enterprise Architect, Rhapsody o Papyrus) o un progetto .mdzip di Cameo o MagicDraw. Holarch lo converte in testo SysML v2, controlla il testo e mostra un rapporto di conversione che contrassegna ogni elemento come convertito, approssimato od omesso, con il motivo, prima che cambi qualsiasi cosa. I layout dei diagrammi non vengono convertiti, quindi il risultato va considerato un punto di partenza per il ripensamento descritto sopra, non una migrazione conclusa. Si veda importare modelli SysML v1.
Anche i progetti LML importano XMI SysML 1.x, ed esportano di nuovo il modello come XMI SysML 1.6 o come file .uml di Papyrus; un file modificato in Papyrus si reimporta nello stesso progetto e aggiorna gli elementi sul posto in base all’id XMI. Si veda importare un modello UML/SysML e andata e ritorno con Papyrus.
Dove andare dopo
- Tutorial di SysML v2: costruire passo per passo un piccolo sistema nella notazione testuale.
- Strumenti SysML v2: che cosa controllare prima di sceglierne uno: una checklist e un modello di prova per qualsiasi strumento candidato.
- Progetti SysML v2 in Holarch: testo, viste e pagine di ingegneria su un unico modello.
- Copertura del linguaggio SysML v2: che cosa supporta il motore e le sue lacune note.
- Scambiare modelli SysML v2: testo, JSON e repository della Systems Modeling API.