Holarch Language Engine
Résultats de test du Language Engine
Résultats mesurés du moteur qui fait fonctionner les projets SysML v2 de Holarch : comment ses réponses se comparent à celles de l'implémentation pilote de l'OMG sur les modèles d'exemple officiels, comment il traite le texte endommagé, et quelle est sa vitesse sur de grands modèles. Les critères non satisfaits sont listés avec ceux qui le sont.
Aller à : Cette exécution · Synthèse · Mémoire de session · Ce que les preuves permettent d'affirmer · Modèles d'exemple · Validation des diagnostics · Liaison des noms · Texte endommagé · Vitesse et mémoire · Pas encore pris en charge · Reproduire les résultats · Exécutions antérieures · Ce que ces résultats ne montrent pas
Cette exécution
- Moteur : Holarch Language Engine 2.1 (version 2.1.1, build 37168cc). Holarch livre la version 2.1.2, qui ajoute des rapports de progression pour la barre de progression de l'hôte et contrôle les très longues chaînes d'imports ou de spécialisations qui bloquaient les versions antérieures ; sur les modèles d'exemple, les modèles générés et le corpus de test de cette exécution, elle donne les mêmes réponses que la 2.1.1, si bien que les chiffres de cette page, mesurés sur la 2.1.1, n'ont pas été remesurés. Son analyse à froid des grands modèles générés a pris environ 3 % de temps en plus lors d'une mesure hors des exécutions officielles. Le moteur 2.1 ajoute la variabilité, les mots-clés définis par l'utilisateur, les déclencheurs et effets de transitions, la simulation (un module complémentaire sous licence séparée, non mesuré ici) et une mémoire réduite au cours d'une session d'édition.
- Méthode : version 10 du plan de recette écrit. Les critères ont été fixés avant la mesure des premiers résultats. Chaque modification ultérieure de la méthode est consignée avec sa raison, et les résultats antérieurs conservent la méthode selon laquelle ils ont été mesurés. Les versions 8 à 10 retirent la variabilité, les mots-clés définis par l'utilisateur et les déclencheurs et effets de transitions de la liste des constructions non prises en charge, au fur et à mesure de leur livraison ; les critères et les seuils sont inchangés.
- Modèles d'exemple : les ensembles training, examples et validation du dépôt des versions SysML v2 de l'OMG, version 2026-08 (commit fb97b754) : 252 fichiers, 14 957 lignes. Les modèles sont récupérés depuis le dépôt de l'OMG à chaque exécution et ne sont pas copiés dans Holarch.
- Référence : l'implémentation pilote de l'OMG, version 0.62.0, exécutée comme une boîte noire.
- Grands modèles : des modèles générés de 10 000 à 250 000 lignes avec des imports profonds, des références entre packages et de longues chaînes de spécialisation.
Chaque chiffre de cette page provient des exécutions officielles nommées ci-dessous. Une exécution publiée n'est jamais modifiée. Une correction est une nouvelle exécution qui désigne celle qu'elle remplace.
Revue interne signale chaque classification et chaque revue de cette page : les classes de désaccords, le registre, la revue de chaque erreur du moteur et les catégories de liaison. Elles ont été établies par Holarch à partir du texte de la spécification. Aucune revue externe n'existe encore ; l'étiquette reste jusqu'à ce qu'il y en ait une.
| Version de Holarch | Version du moteur | Build du moteur | Méthode | Exécutions officielles |
|---|---|---|---|---|
| 2.21.0 (livre le moteur 2.1.2) | 2.1.1 | 37168cc | 10 | 2.1.1-37168cc79-1 (toutes les mesures, y compris la caractérisation de la mémoire de session ; les chiffres de cette page) |
| 2.17.1 | 2.0.1 | d8cf5c8 | 7 | 2.0.1-d8cf5c835-1 (vitesse et mémoire, mémoire de session) |
| 2.15.1 | 2.0.0 | dd4fb10 ; 91f058a indique 2.0.0 | 6 | 1.0.0-dd4fb10f5-1 (toutes les mesures), 2.0.0-91f058a75-1 (toutes les mesures, sur la build qui indique 2.0.0 ; y compris la caractérisation de la mémoire de session) |
| 2.15.0 | 1.0.0 | e6bb924 | 5 | 1.0.0-e6bb92459-1 (vitesse et mémoire, couverture des tests) |
| 2.14.0 | 1.0.0 | 0c983e2 | 6 | 1.0.0-0c983e2e8-1 (vitesse et mémoire, pour comparaison) |
| 2.13.1 | 1.0.0 | d3f5d4b | 5 | 1.0.0-d3f5d4b5d-2 (modèles d'exemple), 1.0.0-d3f5d4b5d-1 (autres mesures) |
| 2.12.0 | 1.0.0 | 8a6bf7b | 5 | 1.0.0-8a6bf7b76-2 (modèles d'exemple), 1.0.0-8a6bf7b76-1 (autres mesures) |
| 2.11.0 | 1.0.0 | c184e57 | 3, lu selon la 4 | 1.0.0-c184e57e6-1 |
Synthèse
Sur un modèle généré de 10 000 lignes, le moteur 2.1.1 analyse le modèle entier en 150 ms et le recontrôle après une modification en 1,3 à 6,8 ms (95e centile). Base du moteur, bibliothèque standard chargée : 17 Mio ; une analyse du modèle entier ajoute environ 29 Mio par tranche de 10 000 lignes, et une session d'édition complète environ 33 Mio par tranche de 10 000 lignes. Tous les critères sont satisfaits, y compris la mémoire du moteur sur une session d'édition complète à 100 000 et 250 000 lignes, que les moteurs antérieurs ne satisfaisaient pas. Testé avec des modèles générés jusqu'à 250 000 lignes : vitesse et mémoire à chaque taille.
La mémoire est indiquée par tranche de 10 000 lignes au-dessus de la base du moteur, c'est-à-dire la mémoire du moteur avec la bibliothèque standard chargée et un modèle vide. Les critères s'appliquent au total.
| Mesure | Critère | Moteur 2.1.1 | Satisfait |
|---|---|---|---|
| Modèles d'exemple : plantages et dépassements de délai | Aucun autorisé | Aucun | Oui |
| Modèles d'exemple : concordance d'acceptation, classée | Au moins 98 % des fichiers du périmètre évalué | 252 sur 252 Revue interne | Oui |
| Modèles d'exemple : fausses acceptations | Aucun autorisé | Aucun | Oui |
| Modèles d'exemple : chaque erreur du moteur examinée individuellement | Toutes examinées | 44 sur 44 Revue interne | Oui |
| Liaison des noms | Au moins 99,5 % des liaisons appariées concordent | 4 904 sur 4 908 | Oui |
| Texte endommagé | Sept critères, ci-dessous | Les sept satisfaits | Oui |
| Modifications, toutes tailles | Modification de valeur en 12 ms, autres modifications en 60 ms (25 et 150 ms à 250 000 lignes) | Toutes dans les limites | Oui |
| Analyse à froid, 100 000 lignes | Indiqué, n'est plus un objectif depuis la version 4 de la méthode (objectif antérieur : en 0,6 s) | 1,43 s | Objectif antérieur non satisfait |
| Analyse à froid, 250 000 lignes | Indiqué, n'est plus un objectif depuis la version 4 de la méthode (objectif antérieur : en 1,2 s) | 3,73 s | Objectif antérieur non satisfait |
| Progression affichée pendant une longue analyse | Une barre de progression pour toute analyse pouvant durer plus de 3 secondes (version 4 de la méthode) | Affichée, avec les étapes du moteur ; vérifiée par le test de progression de Holarch | Oui |
| Mémoire du moteur, analyse à froid, 100 000 lignes | Dans la limite de 512 Mio | 28 Mio par tranche de 10 000 lignes au-dessus de la base | Oui |
| Mémoire du moteur, analyse à froid, 250 000 lignes | Dans la limite de 1 Gio | 28 Mio par tranche de 10 000 lignes au-dessus de la base | Oui |
| Mémoire du moteur, session d'édition complète, 100 000 lignes | Dans la limite de 512 Mio (version 6 de la méthode) | 33 Mio par tranche de 10 000 lignes au-dessus de la base | Oui |
| Mémoire du moteur, session d'édition complète, 250 000 lignes | Dans la limite de 1 Gio (version 6 de la méthode) | 33 Mio par tranche de 10 000 lignes au-dessus de la base | Oui |
| Croissance avec la taille du modèle | Analyse à froid à 250 000 lignes au plus 40 fois celle à 10 000 | 24,9 fois | Oui |
| Même requête, même réponse | Chaque réponse identique dans deux processus neufs | 1 211 sur 1 211 | Oui |
Mémoire de session : critère satisfait
Satisfait : mémoire du moteur sur une session d'édition complète à 100 000 et 250 000 lignes. Les moteurs jusqu'à la 2.0.1 ne le satisfaisaient pas à 250 000 lignes (ni la 2.0.0 à 100 000 lignes) ; le moteur 2.1.1 a besoin d'environ 33 Mio par tranche de 10 000 lignes au-dessus de la base sur toute la session, dans la limite de 512 Mio à 100 000 lignes et de 1 Gio à 250 000 lignes.
- Ce qui a changé. L'imprimeur et le comparateur de texte ne construisent plus de copie complète du document en mémoire (moteur 2.0.1), et les tables de noms, le cache d'analyse, l'arbre syntaxique et les positions de source du moteur occupent moins de place (moteur 2.1.1).
- L'impression d'un modèle entier, auparavant l'étape la plus lourde, nécessite désormais environ 40 Mio par tranche de 10 000 lignes au-dessus de la base en natif, moins qu'une nouvelle analyse complète du modèle à côté d'une session ouverte (environ 54 Mio par tranche de 10 000 lignes) : mémoire sur une longue session.
- Dans le navigateur, la mémoire du moteur ne diminue jamais, si bien qu'un worker conserve la taille de son pic jusqu'à ce qu'il soit terminé ; Holarch termine et redémarre un worker de moteur inactif qui détient beaucoup plus de mémoire qu'il n'en utilise.
Ce que les preuves permettent d'affirmer
Les usages que ces résultats étayent, et où s'arrêtent les preuves. « Non établi » signifie que cette page ne contient aucune preuve dans un sens ou dans l'autre.
| Usage | Étayé par | Établi | Non établi |
|---|---|---|---|
| Assistance à l'édition (analyse pendant la saisie) | Temps de modification, texte endommagé, modèles d'exemple, mémoire de session | Nouvelle analyse après une modification dans les limites des critères jusqu'à 250 000 lignes, en natif et dans Safari ; texte endommagé traité selon les sept critères ; la mémoire se stabilise pendant une longue édition ; mémoire sur une session d'édition complète dans les limites des critères jusqu'à 250 000 lignes | Temps sur des ordinateurs plus lents que celui de mesure (une marge de 4 fois est supposée, non mesurée) ; navigateurs autres que Safari |
| Contrôle par lots et en CI (modèles entiers) | Modèles d'exemple, validation des diagnostics, analyse à froid, même requête même réponse | Aucun plantage ni dépassement de délai ; 252 fichiers d'exemple sur 252 concordent après classification Revue interne ; chaque erreur du moteur examinée ; réponses identiques dans des processus neufs ; l'analyse à froid croît proportionnellement à la taille du modèle | Grands modèles écrits par des personnes ou par d'autres outils (seuls des modèles générés et les exemples de l'OMG ont été mesurés) ; une intégration CI |
| Transformation de modèle (impression d'un modèle sous forme de texte, réécriture du texte dans le modèle) | Session d'édition complète, mémoire de session | Chaque étape répond quelle que soit la taille du modèle ; mémoire dans les limites des critères pour l'impression du modèle entier jusqu'à 250 000 lignes, en natif | Si l'impression et la réécriture donnent le même modèle (ne fait pas partie de ces mesures) ; conversion depuis SysML v1 |
| Navigateur (WebAssembly) | Temps dans Safari, mémoire de session dans Safari | Démarrage, analyse à froid et modifications dans Safari jusqu'à 250 000 lignes | Chrome, Firefox et Edge ; navigateurs mobiles ; mémoire de session dans Safari pour ce moteur (mesurée pour la 2.0.1 jusqu'à 250 000 lignes) |
| Natif et serveur | Toutes les mesures de cette page (les critères sont natifs) | Sur un Mac à puce Apple | Autres systèmes d'exploitation et processeurs ; de nombreux modèles à la fois dans un même processus ; sessions serveur de longue durée sur de nombreux projets |
| Usage à haut niveau d'assurance (décisions critiques pour la sécurité ou la mission, preuves de certification) | Aucun à lui seul | Rien au-delà des usages ci-dessus | Une revue externe ; une certification ou qualification de quelque nature que ce soit ; une couverture complète des règles de validation de la spécification ; l'exécution des actions et des machines à états (le module complémentaire de simulation n'est pas mesuré ici) |
Modèles d'exemple
Chaque ensemble de modèles d'exemple est analysé en bloc, comme un seul projet, car les exemples importent des packages les uns des autres. L'implémentation pilote reçoit les mêmes fichiers dans une seule session. Pour chaque fichier, les deux réponses sont comparées : le fichier comporte-t-il des erreurs ou non, et à quel élément chaque nom se lie-t-il.
Concordance d'acceptation
| Décompte | Ce qu'il compte | Moteur 2.1.1 |
|---|---|---|
| Brut | Chaque fichier ; concordance sur la présence ou non d'erreurs dans le fichier, sans classification | 242 sur 252 |
| Périmètre évalué | Fichiers restants après exclusion de ceux dont le désaccord provient d'une construction de la liste des non-prises en charge | 252 sur 252 (aucun exclu) |
| Classé | Concordance au sein du périmètre évalué, un désaccord n'étant compté comme concordance que lorsque la spécification montre que le moteur a raison | 252 sur 252 Revue interne |
- Satisfait : chaque fichier concorde avec le pilote, dont 10 par l'intermédiaire du registre ci-dessous. La variabilité, les mots-clés définis par l'utilisateur et les déclencheurs et effets de transitions sont désormais pris en charge, si bien qu'aucun fichier ne sort du périmètre évalué (11 fichiers en sortaient avec le moteur 2.0.0) ; 10 fichiers de plus sont acceptés sans erreur qu'avec le moteur 2.0.0, et aucun fichier accepté par la 2.0.0 ne comporte désormais d'erreurs.
- Fausses acceptations : 0. Aucun fichier rejeté par le pilote n'est accepté par le moteur.
- Plantages et dépassements de délai : aucun.
Règles de classification Revue interne. Chaque désaccord avec le pilote est examiné individuellement et consigné avec l'une de ces classes avant une exécution, jamais pendant :
- Erreur de l'exemple : le moteur a raison et l'exemple est invalide, avec la clause de la spécification qui le montre. Exemple : une opération arithmétique qui ajoute une longueur à une masse. Compté comme concordance.
- Erreur du pilote : le moteur a raison et la réponse du pilote contredit une clause citée de la spécification. Compté comme concordance.
- Construction non prise en charge : le désaccord provient d'une construction figurant dans la liste publiée des constructions non prises en charge par le moteur (ci-dessous). Le fichier sort du périmètre évalué. Lorsque la construction est livrée, elle quitte la liste et le fichier est de nouveau mesuré.
- Défaut du moteur : un bogue connu du moteur. Jamais compté comme concordance.
Registre des désaccords tranchés par la spécification Revue interne
Dix désaccords comptent comme concordance parce que la spécification montre que le moteur a raison. Chacun est listé ici. Statut de revue : interne signifie examiné par Holarch au regard de la spécification ; une revue externe de ces cas et d'autres est prévue.
| Id | Fichier | Classe | Clause | Preuve | Revue |
|---|---|---|---|---|---|
| R1 | Calculation Definitions (training) | Erreur de l'exemple | SysML 9.8.2 | Une puissance et un terme de dimension vitesse combinés dans une même somme | Interne |
| R2 | Calculation Usages-2 (training) | Erreur de l'exemple | SysML 9.8.2 | Des grandeurs de dimensions différentes combinées dans une même expression | Interne |
| R3 | Dynamics (examples) | Erreur de l'exemple | SysML 9.8.2 | Des grandeurs de dimensions différentes combinées dans une même expression | Interne |
| R4 | Turbojet Stage Analysis (examples) | Erreur de l'exemple | SysML 9.8.2 | Des grandeurs de dimensions différentes combinées dans une même expression | Interne |
| R5 | SimpleQuadcopter (examples) | Erreur de l'exemple | SysML 9.8.2 | Une longueur liée à une valeur sans dimension | Interne |
| R6 | VehicleGeometryAndCoordinateFrames (examples) | Erreur de l'exemple | SysML 9.8.2 | Un nombre simple ajouté à une longueur | Interne |
| R7 | 15_12 Compound Value Type (validation) | Erreur de l'exemple | SysML 9.8.2 | Des grandeurs de dimensions différentes combinées dans une même expression | Interne |
| R8 | AnalysisIndividualExample (examples) | Erreur de l'exemple | SysML 9.8.2 | Une vitesse liée à une caractéristique de consommation de carburant | Interne |
| R9 | 13a Model Containment (validation) | Erreur du pilote | KerML 8.2.3.5.3 | Deux éléments importés différents partagent un nom dans un même espace de noms ; un nom se résout en au plus une appartenance, et le pilote en choisit une | Interne |
| R10 | SysML v2 Spec Annex A SimpleVehicleModel (examples) | Erreur du pilote | KerML 8.2.3.5.3 | Plusieurs imports apportent des éléments de même nom (comme dans R9) ; les redéfinitions et extrémités de connecteurs qui les utilisent en découlent. Le modèle lie aussi une vitesse à une longueur, une erreur de l'exemple | Interne |
Validation des diagnostics Revue interne
La concordance d'acceptation indique seulement si les deux outils rejettent un fichier. Pour vérifier pourquoi le moteur en rejette un, chaque erreur qu'il signale sur les modèles d'exemple, en dehors des lignes comportant une construction non prise en charge, a été examinée individuellement : son code, sa position, la règle qu'elle applique, la clause de la spécification, s'il s'agit de la première erreur d'un problème (primaire) ou de la conséquence d'une autre erreur (cascade), et une décision.
| Décision | Signification | Moteur 2.1.1 |
|---|---|---|
| Confirmée | La spécification étaye l'erreur | 42 |
| Défaut du moteur | Une fausse erreur | 0 |
| Contestée | La spécification ne tranche pas le cas | 2 |
| Lacune connue | L'erreur provient d'une construction de la liste des non-prises en charge | 0 |
| Total | 44 erreurs dans 10 fichiers (22 primaires, 22 en cascade) |
- Aucun défaut du moteur. Aucune erreur ne porte sur une construction que le moteur ne prend pas en charge : les 40 erreurs du moteur 2.0.0 qui provenaient de la variabilité, des mots-clés définis par l'utilisateur et des effets de transitions ont disparu.
- Le même code partout. Un nom qui se résout en plusieurs éléments importés est signalé comme ambigu dans les expressions comme dans les références ; les builds antérieures le signalaient comme non résolu dans les expressions.
- Une seule interprétation. Lorsque des imports apportent deux éléments de même nom et que l'un spécialise l'autre, la description de la spécification et sa règle formelle diffèrent. Le moteur suit la règle formelle et signale le nom comme ambigu. Le pilote accepte de tels noms sans diagnostic.
- Contestées : les 2 erreurs contestées lient une grandeur à une caractéristique typée par un simple nombre réel : aucune contrainte de la spécification ne rend la liaison invalide, mais elle ne peut pas tenir selon la signification de la bibliothèque des grandeurs.
Liaison des noms
Pour chaque nom d'un modèle, les deux outils indiquent l'élément auquel il se lie. Les liaisons que les deux outils indiquent pour le même nom sont appariées et comparées. Le chiffre de concordance ne porte que sur les liaisons appariées ; il ne dit rien des liaisons qu'un seul outil indique, qui sont classées par catégories ci-dessous.
- 4 904 sur 4 908 liaisons appariées concordent.
- Liaisons indiquées par un seul outil : 1 639 par le moteur et 601 par le pilote.
Les 4 désaccords appariés Revue interne
| Liaisons | Où | Cause | Classe |
|---|---|---|---|
| 3 | PartTest (examples) | Le nom de la cible chez le pilote porte son nom court ; même élément | Identité ou normalisation d'élément différente |
| 1 | ActionTest (examples) | Une action d'envoi sans charge utile : le pilote crée sa propre caractéristique de charge utile qui redéfinit celle de la bibliothèque ; même caractéristique par redéfinition | Identité ou normalisation d'élément différente |
Les 3 désaccords du moteur 2.0.0 sur l'accept et l'effet d'une transition ont disparu : le moteur lie désormais l'accepteur et l'effet propres à la transition, comme le fait le pilote.
Liaisons indiquées par un seul outil Revue interne
Classées selon des règles qui examinent chaque liaison, sa cible et la ligne où elle se trouve :
| Catégorie | Moteur seulement | Pilote seulement |
|---|---|---|
| Identité ou normalisation d'élément différente | 1,243 | 370 |
| Implicite supplémentaire (le moteur lie, le pilote n'affiche aucune relation) | 396 | – |
| Manquante (le pilote lie, le moteur non) | – | 231 |
| Construction non prise en charge | 0 | 0 |
| Écart du pilote | 0 trouvé | 0 trouvé |
| Total | 1,639 | 601 |
- L'identité ou normalisation d'élément différente relève surtout de la comparaison, pas du moteur : noms dans les extrémités de connecteurs, de flux et de successions et dans les expressions, que le pilote présente comme des caractéristiques possédées plutôt que comme des relations ; cibles dans cinq packages de la bibliothèque que la comparaison ne peut pas nommer du côté du pilote ; fichiers fournis au pilote par ordre alphabétique dans la comparaison des liaisons, où 217 liaisons de plus s'apparient dans l'ordre des dépendances ; noms courts, ports conjugués, propriétaires sans nom et caractéristiques implicites que le pilote nomme différemment.
- Implicite supplémentaire et manquante sont ce que les règles laissent. Un échantillon montre des chaînes passant par des extrémités d'interfaces, des ports conjugués dans des définitions et des métadonnées ; elles n'ont pas encore été examinées individuellement.
- Corriger la comparaison modifie la mesure ; cela nécessite donc une nouvelle version de la méthode.
Texte endommagé
Les modèles sont endommagés volontairement, une mutation à la fois : accolades retirées ou ajoutées, déclarations tronquées, imports cassés, références circulaires, caractères invalides, modifications aléatoires de jetons et fautes de frappe courantes comme un point-virgule manquant ou un mot-clé mal orthographié. Les entrées sont les modèles de test propres au moteur, un modèle généré et les modèles d'exemple.
| Contrôler | Critère | Résultat | Satisfait |
|---|---|---|---|
| Plantages et dépassements de délai de plus de 10 s | Aucun autorisé | Aucun | Oui |
| Entrées endommagées | Au moins 10 000 | 10,044 | Oui |
| La réponse après chaque modification est égale à une analyse neuve | Toutes | 10 044 sur 10 044 | Oui |
| Réparer le dommage redonne la réponse d'origine | Toutes | 9 830 sur 9 830 | Oui |
| Une mutation donne au plus 3 nouvelles erreurs de syntaxe | Au moins 99 % des cas | 100.0 % | Oui |
| La première erreur de syntaxe pointe dans la déclaration endommagée ou juste après | Au moins 95 % des cas | 99,7 % de 7 163 | Oui |
| Les déclarations hors de la zone endommagée sont toujours contrôlées de la même façon | Au moins 99 % | 99,5 % de 55 225 | Oui |
Vitesse et mémoire
Les critères portent sur la build native du moteur. Dans Holarch, le moteur s'exécute en WebAssembly dans le navigateur, ce qui est plus lent ; les critères en tiennent compte, ainsi que des ordinateurs plus lents, avec un facteur 8 pour les modifications et l'analyse. La build WebAssembly est aussi mesurée dans Safari (ci-dessous).
Base du moteur, bibliothèque standard chargée : 17 Mio. Les chiffres de mémoire ci-dessous sont exprimés par tranche de 10 000 lignes au-dessus de cette base : le pic moins la base, divisé par la taille du modèle en unités de 10 000 lignes. Les critères s'appliquent au total.
Modifications
Chaque type de modification est appliqué 200 fois, après 20 modifications d'échauffement, dans une même session d'édition, comme l'éditeur de Holarch les envoie. Le tableau indique le 95e centile : 95 modifications sur 100 ont été au moins aussi rapides.
| Taille du modèle | Modifier une valeur | Renommer une définition | Modifier un import | Modifier un supertype | Satisfait |
|---|---|---|---|---|---|
| 10 038 lignes | 1.3 | 6.8 | 2.1 | 2.2 | Oui |
| 50 013 lignes | 3.9 | 19.4 | 4.9 | 4.7 | Oui |
| 100 033 lignes | 7.7 | 34.6 | 8.6 | 8.5 | Oui |
| 250 011 lignes | 22.7 | 90.8 | 24.0 | 24.9 | Oui |
Critères : une modification de valeur en 12 ms (25 ms à 250 000 lignes) ; un renommage, une modification d'import ou de supertype en 60 ms (150 ms à 250 000 lignes).
Analyser un modèle entier
Analyse à froid : un processus neuf avec la bibliothèque standard chargée analyse le modèle entier à partir de rien, médiane de 5 exécutions. La mémoire du moteur est le pic du moteur pendant cette analyse, par tranche de 10 000 lignes au-dessus de la base. La mémoire WebAssembly de la même analyse est indiquée pour référence, par tranche de 10 000 lignes, mémoire de démarrage propre au moteur comprise.
| Taille du modèle | Analyse à froid | Mémoire du moteur, analyse à froid | Mémoire WebAssembly, analyse à froid |
|---|---|---|---|
| 10 038 lignes | 150 ms | 29 Mio par tranche de 10 000 lignes | 38 Mio par tranche de 10 000 lignes |
| 50 013 lignes | 711 ms | 28 Mio par tranche de 10 000 lignes | 29 Mio par tranche de 10 000 lignes |
| 100 033 lignes | 1,43 s | 28 Mio par tranche de 10 000 lignes | 28 Mio par tranche de 10 000 lignes |
| 250 011 lignes | 3,73 s | 28 Mio par tranche de 10 000 lignes | 26 Mio par tranche de 10 000 lignes |
- Analyse à froid selon la version 3 de la méthode : objectif non satisfait. L'objectif était de 0,6 s à 100 000 lignes et de 1,2 s à 250 000 lignes ; une première analyse d'un très grand modèle prend 1,43 s et 3,73 s. D'autres travaux s'exécutaient sur l'ordinateur de mesure pendant cette exécution, si bien que ces temps peuvent être surévalués de quelques pour cent ; les chiffres de mémoire n'en dépendent pas.
- Analyse à froid selon la version 4 de la méthode : indiquée, pas un objectif. Le critère de progression est satisfait. Holarch affiche une barre de progression pour toute analyse pouvant durer plus de 3 secondes : elle apparaît une seconde après le début d'une longue analyse, nomme l'étape (démarrage du moteur, chargement de la bibliothèque standard, analyse du modèle) et reste affichée jusqu'à la fin de l'analyse. La barre de progression est la façon dont l'application gère une longue première analyse ; ce n'est pas une affirmation sur la vitesse du moteur.
- Satisfait : les modifications après cette première analyse respectent leurs critères à toutes les tailles.
- Satisfait : mémoire du moteur pour une analyse à froid dans la limite de 512 Mio à 100 000 lignes et de 1 Gio à 250 000 lignes.
- Satisfait : le temps croît proportionnellement à la taille du modèle. L'analyse à froid à 250 000 lignes prend 24,9 fois plus de temps qu'à 10 000 lignes, pour un modèle 25 fois plus grand (critère : au plus 40).
Une session d'édition complète
Version 6 de la méthode, lue selon la version 7 depuis le moteur 2.0.1 : l'outil de mesure conserve les enregistrements du modèle sous forme de texte, comme le fait Holarch. Un processus neuf exécute un script fixe : la première analyse, les enregistrements d'éléments du modèle, un premier contrôle du modèle, 60 modifications (20 modifications de valeur, 20 modifications d'import et 20 modifications de supertype, chacune analysée de nouveau), l'impression du modèle sous forme de texte, la réécriture du texte modifié dans le modèle et l'évaluation des valeurs du modèle. Le chiffre est la mémoire maximale du moteur à tout moment de la session.
| Taille du modèle | Moteur 2.1.1 | Moteur 2.0.1 | Satisfait en 2.1.1 |
|---|---|---|---|
| 10 038 lignes | 35 Mio par tranche de 10 000 lignes | 51 Mio par tranche de 10 000 lignes | Indiqué |
| 50 013 lignes | 33 Mio par tranche de 10 000 lignes | 49 Mio par tranche de 10 000 lignes | Indiqué |
| 100 033 lignes | 33 Mio par tranche de 10 000 lignes | 49 Mio par tranche de 10 000 lignes | Oui (critère : dans la limite de 512 Mio) |
| 250 011 lignes | 33 Mio par tranche de 10 000 lignes | 50 Mio par tranche de 10 000 lignes | Oui (critère : dans la limite de 1 Gio) |
- Satisfait à 100 000 et 250 000 lignes. Les critères sont ceux de l'analyse à froid : dans la limite de 512 Mio à 100 000 lignes et de 1 Gio à 250 000 lignes, la mémoire qu'un navigateur accorde à une instance WebAssembly avec une marge. En WebAssembly, la mémoire du moteur ne diminue jamais, si bien que le pic d'une session en fixe la taille. Le moteur 2.0.1 satisfaisait le critère à 100 000 lignes mais pas à 250 000 ; le moteur 2.0.0 ne satisfaisait ni l'un ni l'autre (122 Mio par tranche de 10 000 lignes selon la version 6 de la méthode).
- Les pics sont le premier contrôle et l'évaluation du modèle, chacun à peu près aussi lourd que la réécriture du texte dans le modèle ; l'impression du modèle n'est plus l'étape la plus lourde.
Mémoire sur une longue session
Indiqué, pas un critère. Une caractérisation du résultat ci-dessus, en natif, sur le moteur 2.1.1 (exécution 2.1.1-37168cc79-1). Une session par taille de modèle : ouvrir le modèle et le contrôler ; des modifications en deux passes sur chaque site de modification (modifications de valeur, d'import et de supertype, chacune analysée de nouveau), puis des modifications de valeur qui écrivent sans cesse de nouveaux nombres ; dix analyses et dix contrôles du modèle inchangé, et une analyse à partir de zéro à côté de la session ouverte ; l'impression d'un package, puis du modèle entier ; la réécriture du texte dans le modèle ; l'évaluation ; puis fermeture et réouverture trois fois.
| Taille du modèle | Modification du modèle ouvert | Étape la plus lourde : nouvelle analyse à partir de zéro à côté de la session ouverte | Impression du modèle entier | Restant après fermeture |
|---|---|---|---|---|
| 10 038 lignes | 27 Mio | 55 Mio | 41 Mio | 1,5 Mio |
| 50 013 lignes | 26 Mio | 54 Mio | 40 Mio | 0,6 Mio |
| 100 033 lignes | 26 Mio | 54 Mio | 40 Mio | 0,5 Mio |
| 250 011 lignes | 26 Mio | 54 Mio | 40 Mio | 0,4 Mio |
- L'édition se stabilise. La mémoire augmente d'environ 5 Mio par tranche de 10 000 lignes tant que les modifications atteignent des déclarations non encore modifiées, puis reste stable.
- Les analyses répétées ne conservent rien. Dix analyses et dix contrôles d'un modèle inchangé laissent la mémoire là où elle était.
- L'étape la plus lourde est une analyse du modèle entier à partir de zéro pendant que la session reste ouverte, ce qui maintient deux copies de l'analyse à la fois ; un éditeur qui conserve une seule session n'en a pas besoin.
- L'impression du modèle entier nécessite environ 40 Mio par tranche de 10 000 lignes au-dessus de la base (moteur 2.0.1 : 53 à 55 ; moteur 2.0.0 : 129 à 131).
- La fermeture rend la mémoire. Un petit reste subsiste et ne croît pas au fil de trois cycles de réouverture.
- Dans Safari, cette caractérisation n'a pas été exécutée sur le moteur 2.1.1 ; les derniers chiffres de session dans Safari sont ceux du moteur 2.0.1, dans le paquet de preuves.
WebAssembly, mesuré dans Safari
La build WebAssembly du moteur 2.1.1, dans le worker de moteur propre à Holarch, sur les mêmes modèles générés. Le démarrage correspond à la récupération et au lancement du moteur et au chargement de la bibliothèque standard ; l'analyse à froid est la médiane de 3 workers neufs ; les modifications sont au nombre de 200 par type après 20 modifications d'échauffement, dans une même session, comme ci-dessus. Chaque taille de modèle s'est exécutée dans sa propre page. Les renommages ne sont mesurés que dans la build native. Ces chiffres sont indiqués, ce ne sont pas des critères.
| Taille du modèle | Démarrage du moteur, Safari | Analyse à froid, Safari | Analyse à froid, natif | Modifier une valeur, p95, Safari / natif | Modifier un import, p95, Safari / natif | Modifier un supertype, p95, Safari / natif |
|---|---|---|---|---|---|---|
| 10 038 lignes | 143 ms | 215 ms | 150 ms | 3 / 1,3 ms | 4 / 2,1 ms | 4 / 2,2 ms |
| 50 013 lignes | 152 ms | 867 ms | 711 ms | 12 / 3,9 ms | 10 / 4,9 ms | 10 / 4,7 ms |
| 100 033 lignes | 144 ms | 1,63 s | 1,43 s | 20 / 7,7 ms | 20 / 8,6 ms | 20 / 8,5 ms |
| 250 011 lignes | 175 ms | 4,44 s | 3,73 s | 53 / 22,7 ms | 50 / 24,0 ms | 49 / 24,9 ms |
Pas encore pris en charge
Ces constructions figurent dans la liste publiée des constructions non prises en charge par le moteur. Les fichiers des modèles d'exemple en désaccord avec le pilote à cause d'elles sortent du périmètre évalué ; aucun lors de cette exécution.
- Les représentations textuelles dans d'autres langages sont conservées sous forme de texte et non contrôlées.
La variabilité, les mots-clés définis par l'utilisateur et les effets de transitions écrits sous forme d'accept ou d'action ont quitté la liste dans les versions 8 à 10 de la méthode, au fur et à mesure de leur livraison. Chaque production de la grammaire de la notation textuelle a au moins un test qui l'analyse et vérifie le résultat. La liste complète de ce qui fonctionne dans Holarch, avec ses limites : couverture du langage SysML v2.
Reproduire les résultats
Les résultats sont reproductibles de manière indépendante : le paquet de preuves (zip, SHA-256 5d9821f7dac3fd0b2bc49a8defe416ac01f515834d65d3182891a9f8d20e59ae) contient ce qu'il faut pour répéter chaque exécution sur la même build du moteur.
- Un guide de reproduction d'une page,
REPRODUCE.md: les commandes exactes, les dépendances, les entrées avec leurs sommes de contrôle, les résultats attendus et les durées d'exécution. - La méthode de test, avec chaque version de la méthode (1 à 10) et sa raison.
- Les tables de classification : la liste des constructions non prises en charge, chaque désaccord classé avec sa classe et sa clause, le registre ci-dessus, la revue de chaque erreur du moteur et les catégories de liaison.
- La synthèse et les résultats lisibles par machine de chaque exécution pour le moteur 2.1.1 (toutes les mesures et la caractérisation de la mémoire de session), le moteur 2.0.1 (vitesse et mémoire, mémoire de session), Holarch 2.15.1 (les deux builds du code du moteur 2.0.0), 2.14.0 (vitesse et mémoire), 2.13.1 et 2.12.0, ainsi que les temps WebAssembly et la mémoire de session mesurés dans Safari.
- Le générateur des grands modèles, déterministe pour une graine donnée, et les scripts de mesure et de comparaison.
- Une somme de contrôle de chaque fichier.
Il ne contient ni le moteur ni les fichiers de l'OMG. Les scripts récupèrent les modèles d'exemple et l'implémentation pilote depuis leurs sources publiques, au commit et à la somme de contrôle de paquet figés. Le moteur pour une nouvelle exécution est fourni avec une évaluation du moteur.
Exécutions antérieures
Les exécutions officielles antérieures restent telles qu'elles ont été mesurées, chacune selon sa propre version de la méthode. Selon les méthodes 1 à 3, une analyse à froid en 0,6 s à 100 000 lignes était un objectif ; aucune exécution ne l'a atteint. La méthode 4 l'indique sans objectif. Avant la version 3 de la méthode, la mémoire maximale était la mémoire résidente maximale du processus de mesure, qui compte aussi la mémoire que l'allocateur garde pour la réutiliser ; elle n'est pas comparable au chiffre du tas du moteur. Les exécutions Holarch 2.15.0 et 2.14.0 n'ont mesuré que la vitesse et la mémoire ; les temps de l'exécution 2.15.0 sont environ un quart plus élevés que ceux des builds qui la précèdent et la suivent, mesurés pendant que d'autres travaux s'exécutaient sur le même ordinateur.
| Build | Version du moteur | Version de Holarch | Méthode | Acceptation, brut | Acceptation, classé (revue interne) | Liaison des noms | Analyse à froid, 100 000 lignes | Mémoire maximale, 100 000 lignes |
|---|---|---|---|---|---|---|---|---|
| 37168cc | 2.1.1 | 2.21.0 (livre le moteur 2.1.2) | 10 | 242 sur 252 | 252 sur 252 | 4 904 sur 4 908 | 1,43 s | 302 Mio de tas du moteur |
| d8cf5c8 | 2.0.1 | 2.17.1 | 7 | Non mesuré | Non mesuré | Non mesuré | 1,23 s | 362 Mio de tas du moteur |
| 91f058a | 2.0.0 | 2.15.1 (même code de moteur que dd4fb10) | 6 | 232 sur 252 | 241 sur 241 | 4 879 sur 4 886 | 1,35 s | 362 Mio de tas du moteur |
| dd4fb10 | 1.0.0 | 2.15.1 | 6 | 232 sur 252 | 241 sur 241 | 4 879 sur 4 886 | 1,28 s | 362 Mio de tas du moteur |
| e6bb924 | 1.0.0 | 2.15.0 | 5 | Non mesuré | Non mesuré | Non mesuré | 1,57 s | 362 Mio de tas du moteur |
| 0c983e2 | 1.0.0 | 2.14.0 | 6 | Non mesuré | Non mesuré | Non mesuré | 1,37 s | 362 Mio de tas du moteur |
| d3f5d4b | 1.0.0 | 2.13.1, 2.13.2 | 5 | 231 sur 252 | 240 sur 242 | 4 851 sur 4 860 | 1,24 s | 362 Mio de tas du moteur |
| 8a6bf7b | 1.0.0 | 2.12.0 | 5 | 220 sur 252 | 229 sur 242 | 4 753 sur 4 768 | 1,21 s | 362 Mio de tas du moteur |
| 6eec2b7 | 1.0.0 | – | 5 | 231 sur 252 | 240 sur 240 (classification antérieure à la revue des erreurs) | 4 851 sur 4 860 | 1,20 s | 362 Mio de tas du moteur |
| c184e57 | 1.0.0 | 2.11.0 | 3 | 220 sur 252 | 228 sur 228 | 4 753 sur 4 768 | 1,31 s | 361 Mio de tas du moteur |
| bfa03c7 | 1.0.0 | – | 2 | 220 sur 252 | 228 sur 228 | 4 753 sur 4 768 | 1,35 s | 972 Mio de processus |
| 1cada39 | 1.0.0 | – | 2 | 216 sur 252 | 224 sur 228 | 4 737 sur 4 752 | 4,24 s | 1 022 Mio de processus |
| fd20280 | 1.0.0 | – | 1 | 145 sur 252 | Non classé (méthode 1) | 4 326 sur 4 373 | 2,41 s | 1 535 Mio de processus |
Ce que ces résultats ne montrent pas
- Il s'agit des mesures propres à Holarch sur les modèles exécutés. Ce n'est pas une certification. L'Object Management Group ne les a ni examinées ni approuvées.
- L'implémentation pilote et les modèles d'exemple ne sont pas la spécification. Lorsqu'ils diffèrent du moteur, la classification ci-dessus indique quel côté la spécification étaye, et pourquoi.
- Chaque classification et chaque revue de cette page sont des revues internes. Une revue externe d'un échantillon des cas de test du moteur au regard de la spécification est prévue.
- La simulation des actions et des machines à états, le module complémentaire de simulation sous licence séparée, n'est pas mesurée ici.
- La conversion des modèles SysML v1 en SysML v2 n'est pas mesurée ici. Pour les licenciés du moteur, il s'agit du module complémentaire de migration, sous licence séparée.
Essayez le moteur sur vos propres modèles.
L'évaluation est gratuite pendant 60 jours.