Holarch Language Engine
Risultati dei test del Language Engine
Risultati misurati del motore alla base dei progetti SysML v2 di Holarch: come le sue risposte si confrontano con l’implementazione pilota dell’OMG sui modelli di esempio ufficiali, come gestisce il testo danneggiato e quanto è veloce su modelli grandi. I criteri non soddisfatti sono elencati insieme a quelli soddisfatti.
Vai a: Questa esecuzione · Riepilogo · Memoria della sessione · Che cosa sostengono le evidenze · Modelli di esempio · Validazione della diagnostica · Risoluzione dei nomi · Testo danneggiato · Velocità e memoria · Non ancora supportato · Riprodurre i risultati · Esecuzioni precedenti · Che cosa questi risultati non dimostrano
Questa esecuzione
- Motore: Holarch Language Engine 2.1 (versione 2.1.1, build 37168cc). Holarch distribuisce la versione 2.1.2, che aggiunge rapporti di avanzamento per la barra di avanzamento dell’host e controlla catene molto lunghe di import o specializzazioni che bloccavano le versioni precedenti; sui modelli di esempio, sui modelli generati e sul corpus di test di questa esecuzione dà le stesse risposte della 2.1.1, quindi i dati di questa pagina, misurati sulla 2.1.1, non sono stati misurati di nuovo. La sua analisi a freddo dei grandi modelli generati ha richiesto circa il 3 % in più in una misurazione al di fuori delle esecuzioni ufficiali. Il motore 2.1 aggiunge variabilità, parole chiave definite dall’utente, trigger ed effetti delle transizioni, simulazione (un componente aggiuntivo in licenza separata, non misurato qui) e minore memoria nel corso di una sessione di modifica.
- Metodo: versione 10 del piano di accettazione scritto. I criteri sono stati fissati prima di misurare i primi risultati. Ogni modifica successiva del metodo è registrata con il suo motivo, e i risultati precedenti mantengono il metodo con cui sono stati misurati. Le versioni da 8 a 10 tolgono dall’elenco dei costrutti non supportati variabilità, parole chiave definite dall’utente e trigger ed effetti delle transizioni man mano che ciascuno è stato rilasciato; criteri e gate sono invariati.
- Modelli di esempio: gli insiemi training, examples e validation del repository dei rilasci SysML v2 dell’OMG, release 2026-08 (commit fb97b754): 252 file, 14.957 righe. I modelli vengono prelevati dal repository dell’OMG a ogni esecuzione e non vengono copiati in Holarch.
- Riferimento: l’implementazione pilota dell’OMG, versione 0.62.0, eseguita come scatola nera.
- Modelli grandi: modelli generati da 10.000 a 250.000 righe con import profondi, riferimenti tra package e lunghe catene di specializzazione.
Ogni dato di questa pagina proviene dalle esecuzioni ufficiali indicate di seguito. Un’esecuzione pubblicata non viene mai modificata. Una correzione è una nuova esecuzione che indica quella che sostituisce.
Internal review contrassegna ogni classificazione e revisione di questa pagina: le classi di discordanze, il registro, la revisione di ogni errore del motore e le categorie di risoluzione dei nomi. Sono state effettuate da Holarch rispetto al testo della specifica. Non esiste ancora una revisione esterna; l’etichetta resta finché non ce ne sarà una.
| Versione di Holarch | Versione del motore | Build del motore | Metodo | Esecuzioni ufficiali |
|---|---|---|---|---|
| 2.21.0 (distribuisce il motore 2.1.2) | 2.1.1 | 37168cc | 10 | 2.1.1-37168cc79-1 (ogni misura, anche la caratterizzazione della memoria della sessione; i dati di questa pagina) |
| 2.17.1 | 2.0.1 | d8cf5c8 | 7 | 2.0.1-d8cf5c835-1 (velocità e memoria, memoria della sessione) |
| 2.15.1 | 2.0.0 | dd4fb10; 91f058a riporta 2.0.0 | 6 | 1.0.0-dd4fb10f5-1 (ogni misura), 2.0.0-91f058a75-1 (ogni misura, sulla build che riporta 2.0.0; anche la caratterizzazione della memoria della sessione) |
| 2.15.0 | 1.0.0 | e6bb924 | 5 | 1.0.0-e6bb92459-1 (velocità e memoria, copertura dei test) |
| 2.14.0 | 1.0.0 | 0c983e2 | 6 | 1.0.0-0c983e2e8-1 (velocità e memoria, per confronto) |
| 2.13.1 | 1.0.0 | d3f5d4b | 5 | 1.0.0-d3f5d4b5d-2 (modelli di esempio), 1.0.0-d3f5d4b5d-1 (altre misure) |
| 2.12.0 | 1.0.0 | 8a6bf7b | 5 | 1.0.0-8a6bf7b76-2 (modelli di esempio), 1.0.0-8a6bf7b76-1 (altre misure) |
| 2.11.0 | 1.0.0 | c184e57 | 3, letto secondo la 4 | 1.0.0-c184e57e6-1 |
Riepilogo
Su un modello generato di 10.000 righe, il motore 2.1.1 analizza l’intero modello in 150 ms e lo ricontrolla dopo una modifica in 1,3–6,8 ms (95° percentile). Base del motore, con la libreria standard caricata: 17 MiB; un’analisi dell’intero modello aggiunge circa 29 MiB ogni 10.000 righe, e un’intera sessione di modifica circa 33 MiB ogni 10.000 righe. Ogni criterio è soddisfatto, compresa la memoria del motore nel corso di una sessione di modifica completa a 100.000 e 250.000 righe, che i motori precedenti non soddisfacevano. Testato con modelli generati fino a 250.000 righe: velocità e memoria a ogni dimensione.
La memoria è indicata ogni 10.000 righe oltre la base del motore, cioè la memoria del motore con la libreria standard caricata e un modello vuoto. I criteri si applicano al totale.
| Misura | Criterio | Motore 2.1.1 | Soddisfatto |
|---|---|---|---|
| Modelli di esempio: crash e timeout | Nessuno ammesso | Nessuno | Sì |
| Modelli di esempio: concordanza sull’accettazione, classificata | Almeno il 98 % dei file nell’ambito valutato | 252 su 252 Internal review | Sì |
| Modelli di esempio: false accettazioni | Nessuno ammesso | Nessuno | Sì |
| Modelli di esempio: ogni errore del motore esaminato singolarmente | Tutti esaminati | 44 su 44 Internal review | Sì |
| Risoluzione dei nomi | Almeno il 99,5 % delle risoluzioni abbinate concorda | 4.904 su 4.908 | Sì |
| Testo danneggiato | Sette criteri, più avanti | Tutti e sette soddisfatti | Sì |
| Modifiche, tutte le dimensioni | Modifica di un valore entro 12 ms, altre modifiche entro 60 ms (25 e 150 ms a 250.000 righe) | Tutte entro i limiti | Sì |
| Analisi a freddo, 100.000 righe | Riportata, non è un obiettivo dalla versione 4 del metodo (obiettivo precedente: entro 0,6 s) | 1,43 s | Obiettivo precedente non soddisfatto |
| Analisi a freddo, 250.000 righe | Riportata, non è un obiettivo dalla versione 4 del metodo (obiettivo precedente: entro 1,2 s) | 3,73 s | Obiettivo precedente non soddisfatto |
| Avanzamento mostrato durante analisi lunghe | Una barra di avanzamento per qualsiasi analisi che possa durare più di 3 secondi (versione 4 del metodo) | Mostrata, con le fasi del motore; verificata dal test di avanzamento di Holarch | Sì |
| Memoria del motore, analisi a freddo, 100.000 righe | Entro 512 MiB | 28 MiB ogni 10.000 righe oltre la base | Sì |
| Memoria del motore, analisi a freddo, 250.000 righe | Entro 1 GiB | 28 MiB ogni 10.000 righe oltre la base | Sì |
| Memoria del motore, sessione di modifica completa, 100.000 righe | Entro 512 MiB (versione 6 del metodo) | 33 MiB ogni 10.000 righe oltre la base | Sì |
| Memoria del motore, sessione di modifica completa, 250.000 righe | Entro 1 GiB (versione 6 del metodo) | 33 MiB ogni 10.000 righe oltre la base | Sì |
| Crescita con la dimensione del modello | Analisi a freddo a 250.000 righe al massimo 40 volte quella a 10.000 | 24,9 volte | Sì |
| Stessa richiesta, stessa risposta | Ogni risposta identica in due processi nuovi | 1.211 su 1.211 | Sì |
Memoria della sessione: criterio soddisfatto
Soddisfatto: memoria del motore nel corso di una sessione di modifica completa a 100.000 e 250.000 righe. I motori fino alla 2.0.1 non lo soddisfacevano a 250.000 righe (la 2.0.0 nemmeno a 100.000 righe); il motore 2.1.1 richiede circa 33 MiB ogni 10.000 righe oltre la base nel corso dell’intera sessione, entro 512 MiB a 100.000 righe ed entro 1 GiB a 250.000 righe.
- Che cosa è cambiato. La stampa e il confronto del testo non costruiscono più una copia completa del documento in memoria (motore 2.0.1), e le tabelle dei nomi, la cache di analisi, l’albero sintattico e le posizioni nel sorgente del motore occupano meno spazio (motore 2.1.1).
- La stampa di un intero modello, in precedenza il passo più grande, ora richiede in modo nativo circa 40 MiB ogni 10.000 righe oltre la base, meno che rianalizzare il modello da zero accanto a una sessione aperta (circa 54 MiB ogni 10.000 righe): memoria nel corso di una sessione lunga.
- Nel browser la memoria del motore non si riduce mai, quindi un worker mantiene la dimensione del suo momento di picco finché non viene terminato; Holarch termina e riavvia un worker del motore inattivo che occupa molta più memoria di quanta ne usi.
Che cosa sostengono le evidenze
Quali usi sostengono questi risultati, e dove si fermano le evidenze. «Non stabilito» significa che questa pagina non ha evidenze né in un senso né nell’altro.
| Uso | Sostenuto da | Stabilito | Non stabilito |
|---|---|---|---|
| Assistenza all’editor (analisi durante la digitazione) | Tempi delle modifiche, testo danneggiato, modelli di esempio, memoria della sessione | Rianalisi dopo una modifica entro i criteri fino a 250.000 righe, in modo nativo e in Safari; testo danneggiato gestito in tutti e sette i criteri; la memoria si stabilizza durante modifiche prolungate; memoria nel corso di una sessione di modifica completa entro i criteri fino a 250.000 righe | Tempi su computer più lenti di quello di misura (si assume un margine di 4 volte, non misurato); browser diversi da Safari |
| Controllo batch e CI (modelli interi) | Modelli di esempio, validazione della diagnostica, analisi a freddo, stessa richiesta stessa risposta | Nessun crash o timeout; 252 file di esempio su 252 concordano dopo la classificazione Internal review; ogni errore del motore esaminato; risposte identiche in processi nuovi; l’analisi a freddo cresce in proporzione alla dimensione del modello | Modelli grandi scritti da persone o da altri strumenti (sono stati misurati solo modelli generati e gli esempi dell’OMG); un’integrazione CI |
| Trasformazione di modelli (stampare un modello come testo, riscrivere il testo nel modello) | Sessione di modifica completa, memoria della sessione | Ogni passo risponde per ogni dimensione del modello; memoria entro i criteri per la stampa dell’intero modello fino a 250.000 righe, in modo nativo | Se stampa e riscrittura danno lo stesso modello (non fa parte di queste misure); conversione da SysML v1 |
| Browser (WebAssembly) | Tempi in Safari, memoria della sessione in Safari | Avvio, analisi a freddo e modifiche in Safari fino a 250.000 righe | Chrome, Firefox ed Edge; browser per dispositivi mobili; memoria della sessione in Safari per questo motore (misurata per la 2.0.1 fino a 250.000 righe) |
| Nativo e server | Ogni misura di questa pagina (i criteri sono nativi) | Su un Mac con Apple silicon | Altri sistemi operativi e processori; molti modelli contemporaneamente in un unico processo; sessioni server di lunga durata su molti progetti |
| Uso ad alta affidabilità (decisioni critiche per la sicurezza o la missione, evidenze di certificazione) | Nessuna da sola | Nulla oltre agli usi sopra | Una revisione esterna; certificazione o qualifica di qualsiasi tipo; copertura completa delle regole di validazione della specifica; esecuzione di action e macchine a stati (il componente aggiuntivo di simulazione non è misurato qui) |
Modelli di esempio
Ogni insieme di modelli di esempio viene analizzato insieme, come un unico progetto, perché gli esempi importano package l’uno dall’altro. L’implementazione pilota riceve gli stessi file in un’unica sessione. Per ogni file si confrontano le due risposte: il file ha errori o no, e a quale elemento si lega ogni nome.
Concordanza sull’accettazione
| Conteggio | Che cosa conta | Motore 2.1.1 |
|---|---|---|
| Grezzo | Ogni file; concordanza sul fatto che il file abbia errori, senza classificazione | 242 su 252 |
| Ambito valutato | I file che restano dopo aver escluso quelli la cui discordanza deriva da un costrutto dell’elenco dei non supportati | 252 su 252 (nessuno escluso) |
| Classificato | Concordanza nell’ambito valutato, contando una discordanza come concordanza solo dove la specifica mostra che il motore ha ragione | 252 su 252 Internal review |
- Soddisfatto: ogni file concorda con l’implementazione pilota, 10 di essi tramite il registro qui sotto. Variabilità, parole chiave definite dall’utente e trigger ed effetti delle transizioni sono ora supportati, quindi nessun file esce dall’ambito valutato (11 file ne uscivano con il motore 2.0.0); 10 file in più vengono accettati senza errori rispetto al motore 2.0.0, e nessun file accettato dalla 2.0.0 ha ora errori.
- False accettazioni: 0. Nessun file rifiutato dall’implementazione pilota viene accettato dal motore.
- Crash e timeout: nessuno.
Regole di classificazione Internal review. Ogni discordanza con l’implementazione pilota viene analizzata singolarmente e registrata con una di queste classi prima di un’esecuzione, mai durante:
- Errore dell’esempio: il motore ha ragione e l’esempio non è valido, con la clausola della specifica che lo dimostra. Esempio: un’operazione aritmetica che somma una lunghezza a una massa. Contato come concordanza.
- Errore dell’implementazione pilota: il motore ha ragione e la risposta dell’implementazione pilota contraddice una clausola citata della specifica. Contato come concordanza.
- Costrutto non supportato: la discordanza deriva da un costrutto dell’elenco pubblicato dei costrutti non supportati dal motore (più avanti). Il file esce dall’ambito valutato. Quando il costrutto viene rilasciato, esce dall’elenco e il file viene misurato di nuovo.
- Difetto del motore: un bug noto del motore. Mai contato come concordanza.
Registro delle discordanze risolte dalla specifica Internal review
Dieci discordanze contano come concordanza perché la specifica mostra che il motore ha ragione. Ciascuna è elencata qui. Stato della revisione: interna significa esaminata rispetto alla specifica da Holarch; è prevista una revisione esterna di questi e di altri casi.
| Id | File | Classe | Clausola | Evidenze | Revisione |
|---|---|---|---|---|---|
| R1 | Calculation Definitions (training) | Errore dell’esempio | SysML 9.8.2 | Un termine di potenza e uno con dimensione di velocità combinati in un’unica somma | Interna |
| R2 | Calculation Usages-2 (training) | Errore dell’esempio | SysML 9.8.2 | Grandezze di dimensioni diverse combinate in un’unica espressione | Interna |
| R3 | Dynamics (examples) | Errore dell’esempio | SysML 9.8.2 | Grandezze di dimensioni diverse combinate in un’unica espressione | Interna |
| R4 | Turbojet Stage Analysis (examples) | Errore dell’esempio | SysML 9.8.2 | Grandezze di dimensioni diverse combinate in un’unica espressione | Interna |
| R5 | SimpleQuadcopter (examples) | Errore dell’esempio | SysML 9.8.2 | Una lunghezza legata a un valore adimensionale | Interna |
| R6 | VehicleGeometryAndCoordinateFrames (examples) | Errore dell’esempio | SysML 9.8.2 | Un numero semplice sommato a una lunghezza | Interna |
| R7 | 15_12 Compound Value Type (validation) | Errore dell’esempio | SysML 9.8.2 | Grandezze di dimensioni diverse combinate in un’unica espressione | Interna |
| R8 | AnalysisIndividualExample (examples) | Errore dell’esempio | SysML 9.8.2 | Una velocità legata a una feature di consumo di carburante | Interna |
| R9 | 13a Model Containment (validation) | Errore dell’implementazione pilota | KerML 8.2.3.5.3 | Due diversi elementi importati condividono un nome in uno stesso namespace; un nome si risolve al massimo in una membership, e l’implementazione pilota ne sceglie una | Interna |
| R10 | SysML v2 Spec Annex A SimpleVehicleModel (examples) | Errore dell’implementazione pilota | KerML 8.2.3.5.3 | Più import introducono elementi con lo stesso nome (come in R9); ne derivano le ridefinizioni e gli estremi dei connettori che li usano. Il modello lega anche una velocità a una lunghezza, un errore dell’esempio | Interna |
Validazione della diagnostica Internal review
La concordanza sull’accettazione dice solo se entrambi gli strumenti rifiutano un file. Per verificare perché il motore ne rifiuta uno, ogni errore che segnala sui modelli di esempio, al di fuori delle righe con un costrutto non supportato, è stato esaminato singolarmente: il suo codice, la sua posizione, la regola che applica, la clausola della specifica, se è il primo errore di un problema (primario) o una conseguenza di un altro errore (a cascata), e una decisione.
| Esito | Significato | Motore 2.1.1 |
|---|---|---|
| Confermato | La specifica sostiene l’errore | 42 |
| Difetto del motore | Un falso errore | 0 |
| Controverso | La specifica non risolve il caso | 2 |
| Lacuna nota | L’errore deriva da un costrutto dell’elenco dei non supportati | 0 |
| Totale | 44 errori in 10 file (22 primari, 22 a cascata) |
- Nessun difetto del motore. Nessun errore ricade su un costrutto che il motore non supporta: i 40 errori del motore 2.0.0 derivanti da variabilità, parole chiave definite dall’utente ed effetti delle transizioni sono scomparsi.
- Lo stesso codice ovunque. Un nome che si risolve in più elementi importati viene segnalato come ambiguo sia nelle espressioni sia nei riferimenti; le build precedenti lo segnalavano come non risolto nelle espressioni.
- Un’interpretazione. Dove gli import introducono due elementi con lo stesso nome e uno specializza l’altro, la descrizione della specifica e la sua regola formale differiscono. Il motore segue la regola formale e segnala il nome come ambiguo. L’implementazione pilota accetta tali nomi senza diagnostica.
- Controversi: i 2 errori controversi legano una grandezza a una feature tipizzata da un semplice numero reale: nessun vincolo della specifica rende il legame non valido, ma non può essere vero secondo il significato della libreria delle grandezze.
Risoluzione dei nomi
Per ogni nome di un modello, entrambi gli strumenti riportano l’elemento a cui si lega. I legami che entrambi gli strumenti riportano per lo stesso nome vengono abbinati e confrontati. Il dato di concordanza riguarda solo i legami abbinati; non dice nulla sui legami riportati da un solo strumento, che sono suddivisi in categorie più avanti.
- 4.904 su 4.908 legami abbinati concordano.
- Legami riportati da un solo strumento: 1.639 dal motore e 601 dall’implementazione pilota.
Le 4 discordanze abbinate Internal review
| Legami | Dove | Causa | Classe |
|---|---|---|---|
| 3 | PartTest (examples) | Il nome della destinazione nell’implementazione pilota contiene il suo nome breve; stesso elemento | Identità o normalizzazione dell’elemento diversa |
| 1 | ActionTest (examples) | Una send action senza payload: l’implementazione pilota crea una propria feature di payload che ridefinisce quella della libreria; stessa feature per ridefinizione | Identità o normalizzazione dell’elemento diversa |
Le 3 discordanze del motore 2.0.0 su accept ed effect di una transizione sono scomparse: ora il motore lega l’accepter e l’effect propri della transizione, come fa l’implementazione pilota.
Legami riportati da un solo strumento Internal review
Ordinati secondo regole che esaminano ogni legame, la sua destinazione e la riga in cui si trova:
| Categoria | Solo motore | Solo implementazione pilota |
|---|---|---|
| Identità o normalizzazione dell’elemento diversa | 1,243 | 370 |
| Implicito in più (il motore lega, l’implementazione pilota non mostra alcuna relazione) | 396 | – |
| Mancante (l’implementazione pilota lega, il motore no) | – | 231 |
| Costrutto non supportato | 0 | 0 |
| Discrepanza dell’implementazione pilota | 0 trovati | 0 trovati |
| Totale | 1,639 | 601 |
- Identità o normalizzazione dell’elemento diversa riguarda soprattutto il confronto, non il motore: nomi negli estremi di connettori, flussi e successioni e nelle espressioni, che l’implementazione pilota mostra come feature possedute anziché come relazioni; destinazioni in cinque package della libreria che il confronto non sa nominare dal lato dell’implementazione pilota; file forniti all’implementazione pilota in ordine alfabetico nel confronto dei legami, dove altri 217 legami si abbinano nell’ordine delle dipendenze; nomi brevi, porte coniugate, proprietari senza nome e feature implicite che l’implementazione pilota nomina diversamente.
- Implicito in più e mancante sono ciò che le regole lasciano. Un campione mostra catene attraverso estremi di interfacce, porte coniugate nelle definizioni e metadati; non sono ancora stati esaminati singolarmente.
- Correggere il confronto cambia la misura, quindi richiede una nuova versione del metodo.
Testo danneggiato
I modelli vengono danneggiati di proposito, una mutazione alla volta: parentesi graffe rimosse o in più, dichiarazioni troncate, import non validi, riferimenti circolari, caratteri non validi, modifiche casuali di token ed errori di battitura comuni come un punto e virgola mancante o una parola chiave scritta male. Gli input sono i modelli di test del motore stesso, un modello generato e i modelli di esempio.
| Controllo | Criterio | Risultato | Soddisfatto |
|---|---|---|---|
| Crash e timeout oltre 10 s | Nessuno ammesso | Nessuno | Sì |
| Input danneggiati | Almeno 10.000 | 10,044 | Sì |
| La risposta dopo ogni modifica è uguale a un’analisi da zero | Tutti | 10.044 su 10.044 | Sì |
| La riparazione del danno restituisce la risposta originale | Tutti | 9.830 su 9.830 | Sì |
| Una mutazione produce al massimo 3 nuovi errori di sintassi | Almeno il 99 % dei casi | 100.0 % | Sì |
| Il primo errore di sintassi punta all’interno o subito dopo la dichiarazione danneggiata | Almeno il 95 % dei casi | 99,7 % di 7.163 | Sì |
| Le dichiarazioni al di fuori del danno vengono ancora controllate allo stesso modo | Almeno il 99 % | 99,5 % di 55.225 | Sì |
Velocità e memoria
I criteri valgono per la build nativa del motore. In Holarch il motore viene eseguito come WebAssembly nel browser, che è più lento; i criteri ne tengono conto, e dei computer più lenti, con un fattore di 8 per modifiche e analisi. La build WebAssembly viene misurata anche in Safari (più avanti).
Base del motore, con la libreria standard caricata: 17 MiB. I dati di memoria qui sotto sono ogni 10.000 righe oltre questa base: il picco meno la base, diviso per la dimensione del modello in unità di 10.000 righe. I criteri si applicano al totale.
Modifiche
Ogni tipo di modifica viene applicato 200 volte, dopo 20 modifiche di riscaldamento, in un’unica sessione di modifica, nel modo in cui le invia l’editor di Holarch. La tabella mostra il 95° percentile: 95 modifiche su 100 sono state altrettanto veloci o più veloci.
| Dimensione del modello | Modificare un valore | Rinominare una definizione | Modificare un import | Modificare un supertipo | Soddisfatto |
|---|---|---|---|---|---|
| 10.038 righe | 1.3 | 6.8 | 2.1 | 2.2 | Sì |
| 50.013 righe | 3.9 | 19.4 | 4.9 | 4.7 | Sì |
| 100.033 righe | 7.7 | 34.6 | 8.6 | 8.5 | Sì |
| 250.011 righe | 22.7 | 90.8 | 24.0 | 24.9 | Sì |
Criteri: modifica di un valore entro 12 ms (25 ms a 250.000 righe); ridenominazione, modifica di un import o di un supertipo entro 60 ms (150 ms a 250.000 righe).
Analisi di un intero modello
Analisi a freddo: un processo nuovo con la libreria standard caricata analizza l’intero modello da zero, mediana di 5 esecuzioni. La memoria del motore è il picco del motore durante quell’analisi, ogni 10.000 righe oltre la base. La memoria WebAssembly della stessa analisi è mostrata come riferimento, ogni 10.000 righe compresa la memoria di avvio del motore stesso.
| Dimensione del modello | Analisi a freddo | Memoria del motore, analisi a freddo | Memoria WebAssembly, analisi a freddo |
|---|---|---|---|
| 10.038 righe | 150 ms | 29 MiB ogni 10.000 righe | 38 MiB ogni 10.000 righe |
| 50.013 righe | 711 ms | 28 MiB ogni 10.000 righe | 29 MiB ogni 10.000 righe |
| 100.033 righe | 1,43 s | 28 MiB ogni 10.000 righe | 28 MiB ogni 10.000 righe |
| 250.011 righe | 3,73 s | 28 MiB ogni 10.000 righe | 26 MiB ogni 10.000 righe |
- Analisi a freddo secondo la versione 3 del metodo: obiettivo non soddisfatto. L’obiettivo era 0,6 s a 100.000 righe e 1,2 s a 250.000 righe; una prima analisi di un modello molto grande richiede 1,43 s e 3,73 s. Durante questa esecuzione sul computer di misura girava altro lavoro, quindi questi tempi potrebbero risultare più alti di qualche punto percentuale; i dati di memoria non ne dipendono.
- Analisi a freddo secondo la versione 4 del metodo: riportata, non è un obiettivo. Il criterio di avanzamento è soddisfatto. Holarch mostra una barra di avanzamento per qualsiasi analisi che possa durare più di 3 secondi: compare dopo un secondo di un’analisi lunga, indica la fase (avvio del motore, caricamento della libreria standard, analisi del modello) e resta finché l’analisi non termina. La barra di avanzamento è il modo in cui l’app gestisce una prima analisi lunga; non è un’affermazione sulla velocità del motore.
- Soddisfatto: le modifiche dopo quella prima analisi rientrano nei loro criteri a ogni dimensione.
- Soddisfatto: memoria del motore di un’analisi a freddo entro 512 MiB a 100.000 righe ed entro 1 GiB a 250.000 righe.
- Soddisfatto: il tempo cresce in proporzione alla dimensione del modello. L’analisi a freddo a 250.000 righe richiede 24,9 volte il tempo necessario a 10.000 righe, per un modello 25 volte più grande (criterio: al massimo 40).
Un’intera sessione di modifica
Versione 6 del metodo, letta secondo la versione 7 dal motore 2.0.1: lo strumento di misura conserva i record del modello come testo, come fa Holarch. Un processo nuovo esegue uno script fisso: la prima analisi, i record degli elementi del modello, un primo controllo del modello, 60 modifiche (20 modifiche di valori, 20 di import e 20 di supertipi, ciascuna analizzata di nuovo), la stampa del modello come testo, la riscrittura del testo modificato nel modello e la valutazione dei valori del modello. Il dato è la massima memoria del motore in qualsiasi punto della sessione.
| Dimensione del modello | Motore 2.1.1 | Motore 2.0.1 | Soddisfatto nella 2.1.1 |
|---|---|---|---|
| 10.038 righe | 35 MiB ogni 10.000 righe | 51 MiB ogni 10.000 righe | Riportato |
| 50.013 righe | 33 MiB ogni 10.000 righe | 49 MiB ogni 10.000 righe | Riportato |
| 100.033 righe | 33 MiB ogni 10.000 righe | 49 MiB ogni 10.000 righe | Sì (criterio: entro 512 MiB) |
| 250.011 righe | 33 MiB ogni 10.000 righe | 50 MiB ogni 10.000 righe | Sì (criterio: entro 1 GiB) |
- Soddisfatto a 100.000 e 250.000 righe. I criteri sono quelli dell’analisi a freddo: entro 512 MiB a 100.000 righe ed entro 1 GiB a 250.000 righe, la memoria che un browser consente a un’istanza WebAssembly con un margine. In WebAssembly la memoria del motore non si riduce mai, quindi il momento di picco di una sessione ne determina la dimensione. Il motore 2.0.1 soddisfaceva il criterio a 100.000 righe e non a 250.000; il motore 2.0.0 non soddisfaceva nessuno dei due (122 MiB ogni 10.000 righe secondo la versione 6 del metodo).
- I momenti di picco sono il primo controllo e la valutazione del modello, ciascuno grande all’incirca quanto la riscrittura del testo nel modello; la stampa del modello non è più il passo più grande.
Memoria nel corso di una sessione lunga
Riportato, non è un criterio. Una caratterizzazione del risultato sopra, in modo nativo, sul motore 2.1.1 (esecuzione 2.1.1-37168cc79-1). Una sessione per dimensione del modello: aprire il modello e controllarlo; modifiche in due passaggi su ogni punto di modifica (modifiche di valori, import e supertipi, ciascuna analizzata di nuovo), poi modifiche di valori che continuano a scrivere nuovi numeri; dieci analisi e dieci controlli del modello invariato, e un’analisi da zero accanto alla sessione aperta; stampa di un package, poi dell’intero modello; riscrittura del testo nel modello; valutazione; poi chiusura e riapertura per tre volte.
| Dimensione del modello | Modifica del modello aperto | Passo più grande: nuova analisi da zero accanto alla sessione aperta | Stampa dell’intero modello | Residuo dopo la chiusura |
|---|---|---|---|---|
| 10.038 righe | 27 MiB | 55 MiB | 41 MiB | 1,5 MiB |
| 50.013 righe | 26 MiB | 54 MiB | 40 MiB | 0,6 MiB |
| 100.033 righe | 26 MiB | 54 MiB | 40 MiB | 0,5 MiB |
| 250.011 righe | 26 MiB | 54 MiB | 40 MiB | 0,4 MiB |
- La modifica si stabilizza. La memoria cresce di circa 5 MiB ogni 10.000 righe mentre le modifiche raggiungono dichiarazioni non modificate in precedenza, poi resta costante.
- Le analisi ripetute non trattengono nulla. Dieci analisi e dieci controlli di un modello invariato lasciano la memoria dov’era.
- Il passo più grande è un’analisi dell’intero modello da zero mentre la sessione resta aperta, che mantiene due copie dell’analisi contemporaneamente; un editor che mantiene una sola sessione non ne ha bisogno.
- La stampa dell’intero modello richiede circa 40 MiB ogni 10.000 righe oltre la base (motore 2.0.1: da 53 a 55; motore 2.0.0: da 129 a 131).
- La chiusura restituisce la memoria. Resta un piccolo residuo che non cresce nel corso di tre cicli di riapertura.
- In Safari questa caratterizzazione non è stata eseguita sul motore 2.1.1; gli ultimi dati di sessione in Safari sono quelli del motore 2.0.1, nel pacchetto di evidenze.
WebAssembly, misurato in Safari
La build WebAssembly del motore 2.1.1, nel worker del motore di Holarch, sugli stessi modelli generati. L’avvio comprende il download e l’avvio del motore e il caricamento della libreria standard; l’analisi a freddo è la mediana di 3 worker nuovi; le modifiche sono 200 per tipo dopo 20 modifiche di riscaldamento, in un’unica sessione, come sopra. Ogni dimensione del modello è stata eseguita in una pagina propria. Le ridenominazioni sono misurate solo nella build nativa. Questi dati sono riportati, non sono criteri.
| Dimensione del modello | Avvio del motore, Safari | Analisi a freddo, Safari | Analisi a freddo, nativa | Modificare un valore, p95, Safari / nativa | Modificare un import, p95, Safari / nativa | Modificare un supertipo, p95, Safari / nativa |
|---|---|---|---|---|---|---|
| 10.038 righe | 143 ms | 215 ms | 150 ms | 3 / 1,3 ms | 4 / 2,1 ms | 4 / 2,2 ms |
| 50.013 righe | 152 ms | 867 ms | 711 ms | 12 / 3,9 ms | 10 / 4,9 ms | 10 / 4,7 ms |
| 100.033 righe | 144 ms | 1,63 s | 1,43 s | 20 / 7,7 ms | 20 / 8,6 ms | 20 / 8,5 ms |
| 250.011 righe | 175 ms | 4,44 s | 3,73 s | 53 / 22,7 ms | 50 / 24,0 ms | 49 / 24,9 ms |
Non ancora supportato
Questi costrutti sono nell’elenco pubblicato dei costrutti non supportati dal motore. I file dei modelli di esempio che discordano dall’implementazione pilota a causa di essi escono dall’ambito valutato; nessuno in questa esecuzione.
- Le rappresentazioni testuali in altri linguaggi vengono conservate come testo e non vengono controllate.
Variabilità, parole chiave definite dall’utente ed effetti delle transizioni scritti come accept o action sono usciti dall’elenco nelle versioni del metodo da 8 a 10, man mano che ciascuno è stato rilasciato. Ogni produzione grammaticale della notazione testuale ha almeno un test che la analizza e ne controlla il risultato. L’elenco completo di ciò che funziona in Holarch, con i suoi limiti: Copertura del linguaggio SysML v2.
Riprodurre i risultati
I risultati sono riproducibili in modo indipendente: il pacchetto di evidenze (zip, SHA-256 5d9821f7dac3fd0b2bc49a8defe416ac01f515834d65d3182891a9f8d20e59ae) contiene ciò che serve per ripetere ogni esecuzione sulla stessa build del motore.
- Una guida alla riproduzione di una pagina,
REPRODUCE.md: i comandi esatti, le dipendenze, gli input con i loro checksum, i risultati attesi e i tempi di esecuzione. - Il metodo di test, con ogni versione del metodo (da 1 a 10) e il suo motivo.
- Le tabelle di classificazione: l’elenco dei costrutti non supportati, ogni discordanza classificata con la sua classe e la clausola, il registro sopra, la revisione di ogni errore del motore e le categorie di legame.
- Il riepilogo e i risultati leggibili dalla macchina di ogni esecuzione per il motore 2.1.1 (ogni misura e la caratterizzazione della memoria della sessione), il motore 2.0.1 (velocità e memoria, memoria della sessione), Holarch 2.15.1 (entrambe le build del codice del motore 2.0.0), 2.14.0 (velocità e memoria), 2.13.1 e 2.12.0, e i tempi WebAssembly e la memoria della sessione misurati in Safari.
- Il generatore dei modelli grandi, deterministico per seed, e gli script di misura e di confronto.
- Un checksum di ogni file.
Non contiene il motore né i file dell’OMG. Gli script prelevano i modelli di esempio e l’implementazione pilota dalle loro fonti pubbliche al commit fissato e con il checksum del pacchetto. Il motore per una nuova esecuzione è fornito con una valutazione del motore.
Esecuzioni precedenti
Le esecuzioni ufficiali precedenti restano come sono state misurate, ciascuna secondo la propria versione del metodo. Con i metodi da 1 a 3, l’analisi a freddo entro 0,6 s a 100.000 righe era un obiettivo; nessuna esecuzione lo ha raggiunto. Il metodo 4 la riporta senza obiettivo. Il picco di memoria prima della versione 3 del metodo era il picco di memoria residente del processo di misura, che conta anche la memoria che l’allocatore conserva per il riutilizzo; non è confrontabile con il dato dell’heap del motore. Le esecuzioni di Holarch 2.15.0 e 2.14.0 hanno misurato solo velocità e memoria; i tempi dell’esecuzione 2.15.0 sono circa un quarto più alti di quelli delle build precedente e successiva, misurati mentre sullo stesso computer girava altro lavoro.
| Build | Versione del motore | Versione di Holarch | Metodo | Accettazione, grezza | Accettazione, classificata (revisione interna) | Risoluzione dei nomi | Analisi a freddo, 100.000 righe | Picco di memoria, 100.000 righe |
|---|---|---|---|---|---|---|---|---|
| 37168cc | 2.1.1 | 2.21.0 (distribuisce il motore 2.1.2) | 10 | 242 su 252 | 252 su 252 | 4.904 su 4.908 | 1,43 s | 302 MiB di heap del motore |
| d8cf5c8 | 2.0.1 | 2.17.1 | 7 | Non misurato | Non misurato | Non misurato | 1,23 s | 362 MiB di heap del motore |
| 91f058a | 2.0.0 | 2.15.1 (stesso codice del motore di dd4fb10) | 6 | 232 su 252 | 241 su 241 | 4.879 su 4.886 | 1,35 s | 362 MiB di heap del motore |
| dd4fb10 | 1.0.0 | 2.15.1 | 6 | 232 su 252 | 241 su 241 | 4.879 su 4.886 | 1,28 s | 362 MiB di heap del motore |
| e6bb924 | 1.0.0 | 2.15.0 | 5 | Non misurato | Non misurato | Non misurato | 1,57 s | 362 MiB di heap del motore |
| 0c983e2 | 1.0.0 | 2.14.0 | 6 | Non misurato | Non misurato | Non misurato | 1,37 s | 362 MiB di heap del motore |
| d3f5d4b | 1.0.0 | 2.13.1, 2.13.2 | 5 | 231 su 252 | 240 su 242 | 4.851 su 4.860 | 1,24 s | 362 MiB di heap del motore |
| 8a6bf7b | 1.0.0 | 2.12.0 | 5 | 220 su 252 | 229 su 242 | 4.753 su 4.768 | 1,21 s | 362 MiB di heap del motore |
| 6eec2b7 | 1.0.0 | – | 5 | 231 su 252 | 240 su 240 (classificazione precedente alla revisione degli errori) | 4.851 su 4.860 | 1,20 s | 362 MiB di heap del motore |
| c184e57 | 1.0.0 | 2.11.0 | 3 | 220 su 252 | 228 su 228 | 4.753 su 4.768 | 1,31 s | 361 MiB di heap del motore |
| bfa03c7 | 1.0.0 | – | 2 | 220 su 252 | 228 su 228 | 4.753 su 4.768 | 1,35 s | 972 MiB del processo |
| 1cada39 | 1.0.0 | – | 2 | 216 su 252 | 224 su 228 | 4.737 su 4.752 | 4,24 s | 1.022 MiB del processo |
| fd20280 | 1.0.0 | – | 1 | 145 su 252 | Non classificato (metodo 1) | 4.326 su 4.373 | 2,41 s | 1.535 MiB del processo |
Che cosa questi risultati non dimostrano
- Queste sono misurazioni proprie di Holarch sui modelli su cui sono state eseguite. Non sono una certificazione. L’Object Management Group non le ha esaminate né approvate.
- L’implementazione pilota e i modelli di esempio non sono la specifica. Dove essi e il motore differiscono, la classificazione sopra indica quale parte è sostenuta dalla specifica, e perché.
- Ogni classificazione e revisione di questa pagina è una revisione interna. È prevista una revisione esterna di un campione dei casi di test del motore rispetto alla specifica.
- La simulazione di action e macchine a stati, il componente aggiuntivo di simulazione in licenza separata, non è misurata qui.
- La conversione di modelli SysML v1 in SysML v2 non è misurata qui. Per i licenziatari del motore è il componente aggiuntivo di migrazione, in licenza separata.
Provare il motore sui propri modelli.
La valutazione è gratuita per 60 giorni.