Holarch

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
  1. In sintesi
  2. Fondamento: un profilo UML contro KerML
  3. Definizioni e usi invece di blocchi e proprietà
  4. Una notazione testuale standard
  5. Libreria standard, grandezze e unità
  6. Porte, interfacce e connessioni
  7. Comportamento: azioni e stati
  8. Requisiti e casi di verifica
  9. Viste invece di diagrammi disegnati
  10. La Systems Modeling API e lo scambio in JSON
  11. Migrare un modello da SysML v1 a v2
    1. Che cosa si mappa senza problemi
    2. Che cosa va ripensato
  12. Come sono stati controllati i listati
  13. Provarlo in Holarch
  14. 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.

ArgomentoSysML v1SysML v2
FondamentoUn profilo di UML 2: stereotipi su un sottoinsieme delle metaclassi UMLUn proprio metamodello basato sul Kernel Modeling Language (KerML), con una semantica definita in una libreria formale
StrutturaBlocchi con part, reference e value propertyDefinizioni e usi per ogni tipo di elemento: part def e part, port def e port, e così via
NotazioneGrafica (nove tipi di diagramma); nessun testo standard per l’intero modelloUna 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 modelliGrandezze ISQ e unità SI nella libreria standard, usate direttamente nei valori come 6.5 [kg]
InterfacceFull port e proxy port, interface block, flow property, item flow sui connettoriDefinizioni di porta con feature orientate, coniugazione ~, definizioni di interfaccia con estremi tipizzati, flussi e binding
ComportamentoAttività, macchine a stati e interazioni da UML, collegate alla struttura tramite allocazioneAzioni, stati e messaggi come occorrenze, collegati alla struttura tramite perform ed exhibit
RequisitiUna classe stereotipata con un id e un testo; i vincoli si trovano separatamente nei constraint blockUn requisito è un vincolo con un soggetto; testo e condizione verificabile in un unico elemento
VerificaCasi di test collegati tramite verifyCasi di verifica con un obiettivo e un verdetto
DiagrammiDisegni conservati dallo strumento; i layout passano raramente da uno strumento all’altroLe viste sono elementi del modello che dichiarano che cosa mostrano; lo strumento le visualizza
ScambioFile XMI, con differenze tra gli strumentiFile 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 v1SysML v2 in questo listato
Blocco Pump con value propertypart def Pump con attributi
Generalizzazione da ElectricPump a PumpSpecializzazione part def ElectricPump :> Pump
Part property pump di CoolingSystem, tipizzata dal bloccoUso di parte part pump : ElectricPump
Un valore specifico del contesto tramite un blocco specializzato o un’istanzaattribute redefines mass = 2.4 [kg] direttamente sull’uso
Un valore derivato con un constraint block e un diagramma parametricototalMass 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 : MassValue dice 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.mass somma 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 v1SysML v2
Interface block con flow propertyport def con feature in, out o inout
Proxy port o full port tipizzata dall’interface blockUso port tipizzato dalla definizione di porta
Tipo di porta coniugato~CoolantPort
Connettore, eventualmente tipizzato da un association blockconnect … to …, oppure un uso interface tipizzato da una interface def
Binding connectorbind a = b
Item flow su un connettoreUso 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.

Il 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 v1SysML v2
Attività con azioni, flussi di controllo e flussi di oggettiaction def con usi di azione, successioni e flow
Nodi fork, join, decision e mergefork, join, decide e merge
Call behavior actionUn uso di azione tipizzato da un’altra definizione di azione
Partizione o «allocate» dall’attività al bloccoperform nella parte
Macchina a stati posseduta da un bloccostate def, con exhibit state nella parte
Transizione con trigger, guardia ed effettotransition … 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.
  • satisfy e verify mantengono 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 v1Vista SysML v2
Block definition diagram, package diagram, requirement diagramVista generale, con filtri
Internal block diagramVista di interconnessione
Activity diagramAction Flow View
State machine diagramVista di transizione di stato
Sequence diagramVista di sequenza
Parametric diagramVista generale o di interconnessione dei vincoli e dei loro binding
Use case diagramVista 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 totalMass qui sopra.
  • Allocazione. Le partizioni di attività e le relazioni «allocate» dal comportamento alla struttura diventano perform ed exhibit dove 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 expose e filter.
  • 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:

  1. Creare un progetto SysML v2. Si veda primi passi con i progetti SysML v2.
  2. 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.
  3. 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