Holarch Language Engine
Resultados de testes do Language Engine
Resultados medidos do engine por trás dos projetos SysML v2 do Holarch: como suas respostas se comparam com a implementação piloto do OMG nos modelos de exemplo oficiais, como ele lida com texto danificado e quão rápido ele é em modelos grandes. Os critérios não atendidos são listados junto com os atendidos.
Ir para: Esta execução · Resumo · Memória da sessão · O que a evidência sustenta · Modelos de exemplo · Validação de diagnósticos · Vinculação de nomes · Texto danificado · Velocidade e memória · Ainda não suportado · Reproduzir os resultados · Execuções anteriores · O que estes resultados não mostram
Esta execução
- Engine: Holarch Language Engine 2.1 (versão 2.1.1, build 37168cc). O Holarch distribui a versão 2.1.2, que adiciona relatórios de progresso para a barra de progresso do host e checa cadeias muito longas de imports ou especializações que paravam versões anteriores; nos modelos de exemplo, nos modelos gerados e no corpus de testes desta execução, ela dá as mesmas respostas que a 2.1.1, então os números desta página, medidos na 2.1.1, não foram medidos de novo. Sua análise a frio dos grandes modelos gerados levou cerca de 3 % mais tempo em uma medição fora das execuções oficiais. O engine 2.1 adiciona variabilidade, palavras-chave definidas pelo usuário, gatilhos e efeitos de transições, simulação (um complemento licenciado separadamente, não medido aqui) e menor uso de memória ao longo de uma sessão de edição.
- Método: versão 10 do plano de aceitação escrito. Os critérios foram estabelecidos antes de os primeiros resultados serem medidos. Cada mudança posterior de método é registrada com seu motivo, e os resultados anteriores mantêm o método sob o qual foram medidos. As versões 8 a 10 retiram variabilidade, palavras-chave definidas pelo usuário e gatilhos e efeitos de transições da lista de construções não suportadas à medida que cada um foi lançado; critérios e gates não mudaram.
- Modelos de exemplo: os conjuntos de treinamento, exemplos e validação do repositório de releases do SysML v2 do OMG, release 2026-08 (commit fb97b754): 252 arquivos, 14.957 linhas. Os modelos são obtidos do repositório do OMG a cada execução e não são copiados para o Holarch.
- Referência: a implementação piloto do OMG, versão 0.62.0, executada como caixa-preta.
- Modelos grandes: modelos gerados de 10.000 a 250.000 linhas com imports profundos, referências entre pacotes e longas cadeias de especialização.
Cada número desta página vem das execuções oficiais indicadas abaixo. Uma execução publicada nunca é editada. Uma correção é uma nova execução que indica qual ela substitui.
Revisão interna marca cada classificação e revisão desta página: as classes de divergências, o registro, a revisão de cada erro do engine e as categorias de vinculação. Elas foram feitas pelo Holarch com base no texto da especificação. Ainda não existe revisão externa; o rótulo permanece até que exista uma.
| Versão do Holarch | Versão do engine | Build do engine | Método | Execuções oficiais |
|---|---|---|---|---|
| 2.21.0 (distribui o engine 2.1.2) | 2.1.1 | 37168cc | 10 | 2.1.1-37168cc79-1 (todas as medidas, também a caracterização da memória da sessão; os números desta página) |
| 2.17.1 | 2.0.1 | d8cf5c8 | 7 | 2.0.1-d8cf5c835-1 (velocidade e memória, memória da sessão) |
| 2.15.1 | 2.0.0 | dd4fb10; 91f058a informa 2.0.0 | 6 | 1.0.0-dd4fb10f5-1 (todas as medidas), 2.0.0-91f058a75-1 (todas as medidas, no build que informa 2.0.0; também a caracterização da memória da sessão) |
| 2.15.0 | 1.0.0 | e6bb924 | 5 | 1.0.0-e6bb92459-1 (velocidade e memória, cobertura de testes) |
| 2.14.0 | 1.0.0 | 0c983e2 | 6 | 1.0.0-0c983e2e8-1 (velocidade e memória, para comparação) |
| 2.13.1 | 1.0.0 | d3f5d4b | 5 | 1.0.0-d3f5d4b5d-2 (modelos de exemplo), 1.0.0-d3f5d4b5d-1 (outras medidas) |
| 2.12.0 | 1.0.0 | 8a6bf7b | 5 | 1.0.0-8a6bf7b76-2 (modelos de exemplo), 1.0.0-8a6bf7b76-1 (outras medidas) |
| 2.11.0 | 1.0.0 | c184e57 | 3, lida sob a 4 | 1.0.0-c184e57e6-1 |
Resumo
Em um modelo gerado de 10.000 linhas, o engine 2.1.1 analisa o modelo inteiro em 150 ms e o checa de novo após uma edição em 1,3 a 6,8 ms (percentil 95). Base do engine, com a biblioteca padrão carregada: 17 MiB; uma análise do modelo inteiro acrescenta cerca de 29 MiB por 10.000 linhas, e uma sessão de edição inteira cerca de 33 MiB por 10.000 linhas. Todos os critérios são atendidos, incluindo a memória do engine ao longo de uma sessão de edição completa com 100.000 e 250.000 linhas, que engines anteriores não atendiam. Testado com modelos gerados de até 250.000 linhas: velocidade e memória em cada tamanho.
A memória é mostrada por 10.000 linhas acima da base do engine, a memória do engine com a biblioteca padrão carregada e um modelo vazio. Os critérios se aplicam ao total.
| Medida | Critério | Engine 2.1.1 | Atendido |
|---|---|---|---|
| Modelos de exemplo: falhas e tempos esgotados | Nenhum permitido | Nenhum | Sim |
| Modelos de exemplo: concordância de aceitação, classificada | Pelo menos 98 % dos arquivos no escopo avaliado | 252 de 252 Revisão interna | Sim |
| Modelos de exemplo: falsas aceitações | Nenhum permitido | Nenhum | Sim |
| Modelos de exemplo: cada erro do engine revisado individualmente | Todos revisados | 44 de 44 Revisão interna | Sim |
| Vinculação de nomes | Pelo menos 99,5 % das vinculações pareadas concordam | 4.904 de 4.908 | Sim |
| Texto danificado | Sete critérios, abaixo | Todos os sete atendidos | Sim |
| Edições, todos os tamanhos | Mudança de valor em até 12 ms, outras edições em até 60 ms (25 e 150 ms com 250.000 linhas) | Todas dentro | Sim |
| Análise a frio, 100.000 linhas | Informado, não é meta desde a versão 4 do método (meta anterior: em até 0,6 s) | 1,43 s | Meta anterior não atendida |
| Análise a frio, 250.000 linhas | Informado, não é meta desde a versão 4 do método (meta anterior: em até 1,2 s) | 3,73 s | Meta anterior não atendida |
| Progresso mostrado durante análises longas | Uma barra de progresso para qualquer análise que possa levar mais de 3 segundos (versão 4 do método) | Mostrado, com as etapas do engine; checado pelo teste de progresso do Holarch | Sim |
| Memória do engine, análise a frio, 100.000 linhas | Em até 512 MiB | 28 MiB por 10.000 linhas acima da base | Sim |
| Memória do engine, análise a frio, 250.000 linhas | Em até 1 GiB | 28 MiB por 10.000 linhas acima da base | Sim |
| Memória do engine, sessão de edição completa, 100.000 linhas | Em até 512 MiB (versão 6 do método) | 33 MiB por 10.000 linhas acima da base | Sim |
| Memória do engine, sessão de edição completa, 250.000 linhas | Em até 1 GiB (versão 6 do método) | 33 MiB por 10.000 linhas acima da base | Sim |
| Crescimento com o tamanho do modelo | Análise a frio com 250.000 linhas no máximo 40 vezes a de 10.000 | 24,9 vezes | Sim |
| Mesma requisição, mesma resposta | Todas as respostas idênticas em dois processos novos | 1.211 de 1.211 | Sim |
Memória da sessão: critério atendido
Atendido: memória do engine ao longo de uma sessão de edição completa com 100.000 e 250.000 linhas. Os engines até a 2.0.1 não o atendiam com 250.000 linhas (a 2.0.0 também não com 100.000 linhas); o engine 2.1.1 precisa de cerca de 33 MiB por 10.000 linhas acima da base ao longo de toda a sessão, em até 512 MiB com 100.000 linhas e em até 1 GiB com 250.000 linhas.
- O que mudou. O printer e o diff de texto não constroem mais uma cópia completa do documento na memória (engine 2.0.1), e as tabelas de nomes, o cache de análise, a árvore sintática e as posições de origem do engine ocupam menos espaço (engine 2.1.1).
- Imprimir um modelo inteiro, antes a maior etapa, agora precisa de cerca de 40 MiB por 10.000 linhas acima da base em execução nativa, menos do que analisar o modelo de novo do zero ao lado de uma sessão aberta (cerca de 54 MiB por 10.000 linhas): memória ao longo de uma sessão longa.
- No navegador, a memória do engine nunca diminui, então um worker mantém o tamanho do seu maior momento até ser encerrado; o Holarch encerra e reinicia um worker de engine ocioso que ocupa muito mais memória do que usa.
O que a evidência sustenta
Quais usos estes resultados sustentam e onde a evidência termina. “Não estabelecido” significa que esta página não tem evidência nem a favor nem contra.
| Uso | Sustentado por | Estabelecido | Não estabelecido |
|---|---|---|---|
| Assistência no editor (análise durante a digitação) | Tempos de edição, texto danificado, modelos de exemplo, memória da sessão | Reanálise após uma edição dentro dos critérios até 250.000 linhas, em execução nativa e no Safari; texto danificado tratado nos sete critérios; a memória se estabiliza durante edições longas; memória ao longo de uma sessão de edição completa dentro dos critérios até 250.000 linhas | Tempos em computadores mais lentos que o de medição (uma margem de 4 vezes é presumida, não medida); navegadores além do Safari |
| Checagem em lote e em CI (modelos inteiros) | Modelos de exemplo, validação de diagnósticos, análise a frio, mesma requisição mesma resposta | Nenhuma falha ou tempo esgotado; 252 de 252 arquivos de exemplo concordam após a classificação Revisão interna; cada erro do engine revisado; respostas idênticas em processos novos; a análise a frio cresce na proporção do tamanho do modelo | Modelos grandes escritos por pessoas ou outras ferramentas (só foram medidos modelos gerados e os exemplos do OMG); uma integração de CI |
| Transformação de modelos (imprimir um modelo como texto, gravar texto de volta no modelo) | Sessão de edição completa, memória da sessão | Cada etapa responde em todos os tamanhos de modelo; memória dentro dos critérios para impressão do modelo inteiro até 250.000 linhas, em execução nativa | Se imprimir e gravar de volta dão o mesmo modelo (não faz parte destas medidas); conversão a partir do SysML v1 |
| Navegador (WebAssembly) | Tempos no Safari, memória da sessão no Safari | Inicialização, análise a frio e edições no Safari até 250.000 linhas | Chrome, Firefox e Edge; navegadores móveis; memória da sessão no Safari para este engine (medida para a 2.0.1 até 250.000 linhas) |
| Nativo e servidor | Todas as medidas desta página (os critérios são nativos) | Em um Mac com Apple silicon | Outros sistemas operacionais e processadores; muitos modelos ao mesmo tempo em um processo; sessões de servidor de longa duração em muitos projetos |
| Uso de alta garantia (decisões críticas para a segurança ou a missão, evidência de certificação) | Nenhuma por si só | Nada além dos usos acima | Uma revisão externa; certificação ou qualificação de qualquer tipo; cobertura completa das regras de validação da especificação; execução de ações e máquinas de estados (o complemento de simulação não é medido aqui) |
Modelos de exemplo
Cada conjunto de modelos de exemplo é analisado em conjunto, como um único projeto, porque os exemplos importam pacotes uns dos outros. A implementação piloto recebe os mesmos arquivos em uma única sessão. Para cada arquivo, as duas respostas são comparadas: o arquivo tem erros ou não, e a qual elemento cada nome se vincula.
Concordância de aceitação
| Contagem | O que ela conta | Engine 2.1.1 |
|---|---|---|
| Bruta | Cada arquivo; concordância sobre se o arquivo tem erros, sem classificação | 242 de 252 |
| Escopo avaliado | Arquivos restantes após excluir aqueles cuja divergência vem de uma construção da lista de não suportadas | 252 de 252 (nenhum excluído) |
| Classificada | Concordância dentro do escopo avaliado, contando uma divergência como concordância somente quando a especificação mostra que o engine está certo | 252 de 252 Revisão interna |
- Atendido: cada arquivo concorda com o piloto, 10 deles por meio do registro abaixo. Variabilidade, palavras-chave definidas pelo usuário e gatilhos e efeitos de transições agora são suportados, então nenhum arquivo sai do escopo avaliado (11 arquivos saíam para o engine 2.0.0); 10 arquivos a mais são aceitos sem erros do que com o engine 2.0.0, e nenhum arquivo que a 2.0.0 aceitava tem erros agora.
- Falsas aceitações: 0. Nenhum arquivo que o piloto rejeita é aceito pelo engine.
- Falhas e tempos esgotados: nenhum.
Regras de classificação Revisão interna. Cada divergência com o piloto é investigada individualmente e registrada com uma destas classes antes de uma execução, nunca durante ela:
- Erro do exemplo: o engine está certo e o exemplo é inválido, com a cláusula da especificação que o mostra. Exemplo: aritmética que soma um comprimento a uma massa. Conta como concordância.
- Erro do piloto: o engine está certo e a resposta do piloto contradiz uma cláusula citada da especificação. Conta como concordância.
- Construção não suportada: a divergência vem de uma construção da lista publicada de construções não suportadas pelo engine (abaixo). O arquivo sai do escopo avaliado. Quando a construção é lançada, ela sai da lista e o arquivo é medido de novo.
- Defeito do engine: um bug conhecido do engine. Nunca conta como concordância.
Registro de divergências que a especificação resolve Revisão interna
Dez divergências contam como concordância porque a especificação mostra que o engine está certo. Cada uma está listada aqui. Status da revisão: interna significa revisada em relação à especificação pelo Holarch; está planejada uma revisão externa destes e de outros casos.
| Id | Arquivo | Classe | Cláusula | Evidência | Revisão |
|---|---|---|---|---|---|
| R1 | Calculation Definitions (training) | Erro do exemplo | SysML 9.8.2 | Um termo de potência e um termo com dimensão de velocidade combinados em uma única soma | Interna |
| R2 | Calculation Usages-2 (training) | Erro do exemplo | SysML 9.8.2 | Grandezas de dimensões diferentes combinadas em uma única expressão | Interna |
| R3 | Dynamics (examples) | Erro do exemplo | SysML 9.8.2 | Grandezas de dimensões diferentes combinadas em uma única expressão | Interna |
| R4 | Turbojet Stage Analysis (examples) | Erro do exemplo | SysML 9.8.2 | Grandezas de dimensões diferentes combinadas em uma única expressão | Interna |
| R5 | SimpleQuadcopter (examples) | Erro do exemplo | SysML 9.8.2 | Um comprimento vinculado a um valor adimensional | Interna |
| R6 | VehicleGeometryAndCoordinateFrames (examples) | Erro do exemplo | SysML 9.8.2 | Um número simples somado a um comprimento | Interna |
| R7 | 15_12 Compound Value Type (validation) | Erro do exemplo | SysML 9.8.2 | Grandezas de dimensões diferentes combinadas em uma única expressão | Interna |
| R8 | AnalysisIndividualExample (examples) | Erro do exemplo | SysML 9.8.2 | Uma velocidade vinculada a uma feature de economia de combustível | Interna |
| R9 | 13a Model Containment (validation) | Erro do piloto | KerML 8.2.3.5.3 | Dois elementos importados diferentes compartilham um nome em um mesmo namespace; um nome resolve para no máximo uma associação, e o piloto escolhe uma | Interna |
| R10 | SysML v2 Spec Annex A SimpleVehicleModel (examples) | Erro do piloto | KerML 8.2.3.5.3 | Vários imports trazem elementos de um mesmo nome (como no R9); as redefinições e extremidades de conectores que os usam decorrem disso. O modelo também vincula uma velocidade a um comprimento, um erro do exemplo | Interna |
Validação de diagnósticos Revisão interna
A concordância de aceitação diz apenas se as duas ferramentas rejeitam um arquivo. Para checar por que o engine rejeita um, cada erro que ele informa nos modelos de exemplo, fora das linhas com uma construção não suportada, foi revisado individualmente: seu código, sua posição, a regra que aplica, a cláusula da especificação, se é o primeiro erro de um problema (primário) ou consequência de outro erro (cascata), e uma disposição.
| Disposição | Significado | Engine 2.1.1 |
|---|---|---|
| Confirmado | A especificação sustenta o erro | 42 |
| Defeito do engine | Um erro falso | 0 |
| Contestado | A especificação não resolve o caso | 2 |
| Lacuna conhecida | O erro vem de uma construção da lista de não suportadas | 0 |
| Total | 44 erros em 10 arquivos (22 primários, 22 em cascata) |
- Nenhum defeito do engine. Nenhum erro recai sobre uma construção que o engine não suporta: os 40 erros do engine 2.0.0 que vinham de variabilidade, palavras-chave definidas pelo usuário e efeitos de transições desapareceram.
- O mesmo código em toda parte. Um nome que resolve para vários elementos importados é informado como ambíguo tanto em expressões quanto em referências; builds anteriores o informavam como não resolvido em expressões.
- Uma interpretação. Quando imports trazem dois elementos de um mesmo nome e um deles especializa o outro, a descrição da especificação e sua regra formal divergem. O engine segue a regra formal e informa o nome como ambíguo. O piloto aceita esses nomes sem diagnóstico.
- Contestados: os 2 erros contestados vinculam uma grandeza a uma feature tipada por um número real simples: nenhuma restrição da especificação torna a vinculação inválida, mas ela não pode valer segundo o significado da biblioteca de grandezas.
Vinculação de nomes
Para cada nome em um modelo, as duas ferramentas informam o elemento ao qual ele se vincula. As vinculações que as duas ferramentas informam para o mesmo nome são pareadas e comparadas. O número de concordância se refere apenas às vinculações pareadas; ele nada diz sobre as vinculações que só uma ferramenta informa, que são classificadas em categorias abaixo.
- 4.904 de 4.908 vinculações pareadas concordam.
- Vinculações que só uma ferramenta informa: 1.639 do engine e 601 do piloto.
As 4 divergências pareadas Revisão interna
| Vinculações | Onde | Causa | Classe |
|---|---|---|---|
| 3 | PartTest (examples) | O nome do alvo no piloto inclui seu nome curto; mesmo elemento | Identidade ou normalização de elemento diferente |
| 1 | ActionTest (examples) | Uma ação de envio sem payload: o piloto cria sua própria feature de payload que redefine a da biblioteca; mesma feature por redefinição | Identidade ou normalização de elemento diferente |
As 3 divergências do engine 2.0.0 sobre o accept e o efeito de uma transição desapareceram: o engine agora vincula o próprio accepter e o efeito da transição, como faz o piloto.
Vinculações que só uma ferramenta informa Revisão interna
Classificadas por regras que examinam cada vinculação, seu alvo e a linha em que está:
| Categoria | Só o engine | Só o piloto |
|---|---|---|
| Identidade ou normalização de elemento diferente | 1,243 | 370 |
| Implícita extra (o engine vincula, o piloto não mostra relacionamento) | 396 | – |
| Ausente (o piloto vincula, o engine não) | – | 231 |
| Construção não suportada | 0 | 0 |
| Discrepância do piloto | 0 encontradas | 0 encontradas |
| Total | 1,639 | 601 |
- Identidade ou normalização de elemento diferente se deve principalmente à comparação, não ao engine: nomes em extremidades de conectores, fluxos e sucessões e em expressões, que o piloto mostra como features possuídas em vez de relacionamentos; alvos em cinco pacotes de biblioteca que a comparação não consegue nomear do lado do piloto; arquivos fornecidos ao piloto em ordem alfabética na comparação de vinculações, em que 217 vinculações a mais são pareadas na ordem de dependência; nomes curtos, portas conjugadas, proprietários sem nome e features implícitas que o piloto nomeia de outra forma.
- Implícita extra e ausente são o que as regras deixam. Uma amostra mostra cadeias por extremidades de interfaces, portas conjugadas em definições e metadados; elas ainda não foram revisadas individualmente.
- Corrigir a comparação altera a medida, então isso exige uma nova versão do método.
Texto danificado
Os modelos são danificados de propósito, uma mutação por vez: chaves removidas ou a mais, declarações cortadas, imports quebrados, referências circulares, caracteres inválidos, alterações aleatórias de tokens e erros comuns de digitação, como um ponto e vírgula faltando ou uma palavra-chave escrita errado. As entradas são os próprios modelos de teste do engine, um modelo gerado e os modelos de exemplo.
| Checagem | Critério | Resultado | Atendido |
|---|---|---|---|
| Falhas e tempos esgotados acima de 10 s | Nenhum permitido | Nenhum | Sim |
| Entradas danificadas | Pelo menos 10.000 | 10,044 | Sim |
| A resposta após cada edição é igual a uma análise nova | Todas | 10.044 de 10.044 | Sim |
| Reparar o dano devolve a resposta original | Todas | 9.830 de 9.830 | Sim |
| Uma mutação gera no máximo 3 novos erros de sintaxe | Pelo menos 99 % dos casos | 100.0 % | Sim |
| O primeiro erro de sintaxe aponta para dentro ou logo depois da declaração danificada | Pelo menos 95 % dos casos | 99,7 % de 7.163 | Sim |
| Declarações fora do dano continuam sendo checadas da mesma forma | Pelo menos 99 % | 99,5 % de 55.225 | Sim |
Velocidade e memória
Os critérios são para o build nativo do engine. No Holarch, o engine roda como WebAssembly no navegador, o que é mais lento; os critérios levam isso em conta, e também computadores mais lentos, com um fator de 8 para edições e análise. O build WebAssembly também é medido no Safari (abaixo).
Base do engine, com a biblioteca padrão carregada: 17 MiB. Os números de memória abaixo são por 10.000 linhas acima dessa base: o pico menos a base, dividido pelo tamanho do modelo em unidades de 10.000 linhas. Os critérios se aplicam ao total.
Edições
Cada tipo de edição é aplicado 200 vezes, após 20 edições de aquecimento, em uma única sessão de edição, do jeito que o editor do Holarch as envia. A tabela mostra o percentil 95: 95 de cada 100 edições foram tão rápidas ou mais rápidas que isso.
| Tamanho do modelo | Alterar um valor | Renomear uma definição | Alterar um import | Alterar um supertipo | Atendido |
|---|---|---|---|---|---|
| 10.038 linhas | 1.3 | 6.8 | 2.1 | 2.2 | Sim |
| 50.013 linhas | 3.9 | 19.4 | 4.9 | 4.7 | Sim |
| 100.033 linhas | 7.7 | 34.6 | 8.6 | 8.5 | Sim |
| 250.011 linhas | 22.7 | 90.8 | 24.0 | 24.9 | Sim |
Critérios: uma mudança de valor em até 12 ms (25 ms com 250.000 linhas); uma renomeação, mudança de import ou de supertipo em até 60 ms (150 ms com 250.000 linhas).
Análise de um modelo inteiro
Análise a frio: um processo novo com a biblioteca padrão carregada analisa o modelo inteiro do zero, mediana de 5 execuções. A memória do engine é o pico do engine durante essa análise, por 10.000 linhas acima da base. A memória WebAssembly da mesma análise é mostrada como referência, por 10.000 linhas incluindo a memória de inicialização do próprio engine.
| Tamanho do modelo | Análise a frio | Memória do engine, análise a frio | Memória WebAssembly, análise a frio |
|---|---|---|---|
| 10.038 linhas | 150 ms | 29 MiB por 10.000 linhas | 38 MiB por 10.000 linhas |
| 50.013 linhas | 711 ms | 28 MiB por 10.000 linhas | 29 MiB por 10.000 linhas |
| 100.033 linhas | 1,43 s | 28 MiB por 10.000 linhas | 28 MiB por 10.000 linhas |
| 250.011 linhas | 3,73 s | 28 MiB por 10.000 linhas | 26 MiB por 10.000 linhas |
- Análise a frio na versão 3 do método: meta não atendida. A meta era 0,6 s com 100.000 linhas e 1,2 s com 250.000 linhas; uma primeira análise de um modelo muito grande leva 1,43 s e 3,73 s. Outros trabalhos rodaram no computador de medição durante esta execução, então esses tempos podem estar alguns por cento acima; os números de memória não dependem disso.
- Análise a frio na versão 4 do método: informada, não é meta. O critério de progresso é atendido. O Holarch mostra uma barra de progresso para qualquer análise que possa levar mais de 3 segundos: ela aparece um segundo depois do início de uma análise longa, indica a etapa (iniciando o engine, carregando a biblioteca padrão, analisando o modelo) e permanece até a análise terminar. A barra de progresso é como o app lida com uma primeira análise longa; não é uma afirmação sobre a velocidade do engine.
- Atendido: as edições após essa primeira análise ficam dentro de seus critérios em todos os tamanhos.
- Atendido: memória do engine de uma análise a frio em até 512 MiB com 100.000 linhas e em até 1 GiB com 250.000 linhas.
- Atendido: o tempo cresce na proporção do tamanho do modelo. A análise a frio com 250.000 linhas leva 24,9 vezes o tempo de 10.000 linhas, para um modelo 25 vezes maior (critério: no máximo 40).
Uma sessão de edição inteira
Versão 6 do método, lida sob a versão 7 desde o engine 2.0.1: a ferramenta de medição mantém os registros do modelo como texto, como faz o Holarch. Um processo novo executa um script fixo: a primeira análise, os registros de elementos do modelo, uma primeira checagem do modelo, 60 edições (20 mudanças de valor, 20 mudanças de import e 20 mudanças de supertipo, cada uma analisada de novo), a impressão do modelo como texto, a gravação do texto editado de volta no modelo e a avaliação dos valores do modelo. O número é a maior memória do engine em qualquer ponto da sessão.
| Tamanho do modelo | Engine 2.1.1 | Engine 2.0.1 | Atendido na 2.1.1 |
|---|---|---|---|
| 10.038 linhas | 35 MiB por 10.000 linhas | 51 MiB por 10.000 linhas | Informado |
| 50.013 linhas | 33 MiB por 10.000 linhas | 49 MiB por 10.000 linhas | Informado |
| 100.033 linhas | 33 MiB por 10.000 linhas | 49 MiB por 10.000 linhas | Sim (critério: em até 512 MiB) |
| 250.011 linhas | 33 MiB por 10.000 linhas | 50 MiB por 10.000 linhas | Sim (critério: em até 1 GiB) |
- Atendido com 100.000 e 250.000 linhas. Os critérios são os da análise a frio: em até 512 MiB com 100.000 linhas e em até 1 GiB com 250.000 linhas, a memória que um navegador permite a uma instância WebAssembly, com margem. Em WebAssembly, a memória do engine nunca diminui, então o maior momento de uma sessão define seu tamanho. O engine 2.0.1 atendia ao critério com 100.000 linhas e não com 250.000; o engine 2.0.0 não atendia a nenhum dos dois (122 MiB por 10.000 linhas na versão 6 do método).
- Os maiores momentos são a primeira checagem e a avaliação do modelo, cada uma mais ou menos do tamanho da gravação do texto de volta no modelo; imprimir o modelo deixou de ser a maior etapa.
Memória ao longo de uma sessão longa
Informado, não é critério. Uma caracterização do resultado acima, em execução nativa, no engine 2.1.1 (execução 2.1.1-37168cc79-1). Uma sessão por tamanho de modelo: abrir o modelo e checá-lo; edições em duas passadas por cada ponto de edição (mudanças de valor, de import e de supertipo, cada uma analisada de novo), depois edições de valor que continuam gravando novos números; dez análises e dez checagens do modelo inalterado, e uma análise do zero ao lado da sessão aberta; imprimir um pacote e, depois, o modelo inteiro; gravar o texto de volta no modelo; avaliação; depois fechar e reabrir três vezes.
| Tamanho do modelo | Edição do modelo aberto | Maior etapa: analisar de novo do zero ao lado da sessão aberta | Impressão do modelo inteiro | Restante após fechar |
|---|---|---|---|---|
| 10.038 linhas | 27 MiB | 55 MiB | 41 MiB | 1,5 MiB |
| 50.013 linhas | 26 MiB | 54 MiB | 40 MiB | 0,6 MiB |
| 100.033 linhas | 26 MiB | 54 MiB | 40 MiB | 0,5 MiB |
| 250.011 linhas | 26 MiB | 54 MiB | 40 MiB | 0,4 MiB |
- A edição se estabiliza. A memória sobe cerca de 5 MiB por 10.000 linhas enquanto as edições alcançam declarações ainda não editadas, e depois fica estável.
- Análises repetidas não retêm nada. Dez análises e dez checagens de um modelo inalterado deixam a memória onde estava.
- A maior etapa é uma análise do modelo inteiro do zero enquanto a sessão continua aberta, o que mantém duas cópias da análise ao mesmo tempo; um editor que mantém uma única sessão não precisa disso.
- Imprimir o modelo inteiro precisa de cerca de 40 MiB por 10.000 linhas acima da base (engine 2.0.1: 53 a 55; engine 2.0.0: 129 a 131).
- Fechar devolve a memória. Um pequeno restante permanece e não cresce ao longo de três ciclos de reabertura.
- No Safari, esta caracterização não foi executada no engine 2.1.1; os últimos números de sessão no Safari são os do engine 2.0.1, no pacote de evidências.
WebAssembly, medido no Safari
O build WebAssembly do engine 2.1.1, no próprio worker de engine do Holarch, com os mesmos modelos gerados. A inicialização é baixar e iniciar o engine e carregar a biblioteca padrão; a análise a frio é a mediana de 3 workers novos; as edições são 200 por tipo após 20 edições de aquecimento, em uma única sessão, como acima. Cada tamanho de modelo rodou em sua própria página. As renomeações são medidas apenas no build nativo. Estes números são informados, não são critérios.
| Tamanho do modelo | Inicialização do engine, Safari | Análise a frio, Safari | Análise a frio, nativo | Alterar um valor, p95, Safari / nativo | Alterar um import, p95, Safari / nativo | Alterar um supertipo, p95, Safari / nativo |
|---|---|---|---|---|---|---|
| 10.038 linhas | 143 ms | 215 ms | 150 ms | 3 / 1,3 ms | 4 / 2,1 ms | 4 / 2,2 ms |
| 50.013 linhas | 152 ms | 867 ms | 711 ms | 12 / 3,9 ms | 10 / 4,9 ms | 10 / 4,7 ms |
| 100.033 linhas | 144 ms | 1,63 s | 1,43 s | 20 / 7,7 ms | 20 / 8,6 ms | 20 / 8,5 ms |
| 250.011 linhas | 175 ms | 4,44 s | 3,73 s | 53 / 22,7 ms | 50 / 24,0 ms | 49 / 24,9 ms |
Ainda não suportado
Estas construções estão na lista publicada de construções não suportadas pelo engine. Os arquivos dos modelos de exemplo que divergem do piloto por causa delas saem do escopo avaliado; nenhum nesta execução.
- Representações textuais em outras linguagens são mantidas como texto e não são checadas.
Variabilidade, palavras-chave definidas pelo usuário e efeitos de transições escritos como accept ou action saíram da lista nas versões 8 a 10 do método, à medida que cada um foi lançado. Cada produção gramatical da notação textual tem pelo menos um teste que a analisa e checa o resultado. A lista completa do que funciona no Holarch, com seus limites: cobertura da linguagem SysML v2.
Reproduzir os resultados
Os resultados podem ser reproduzidos de forma independente: o pacote de evidências (zip, SHA-256 5d9821f7dac3fd0b2bc49a8defe416ac01f515834d65d3182891a9f8d20e59ae) contém o necessário para repetir cada execução no mesmo build do engine.
- Um guia de reprodução de uma página,
REPRODUCE.md: os comandos exatos, as dependências, as entradas com seus checksums, os resultados esperados e os tempos de execução. - O método de teste, com cada versão do método (1 a 10) e seu motivo.
- As tabelas de classificação: a lista de construções não suportadas, cada divergência classificada com sua classe e cláusula, o registro acima, a revisão de cada erro do engine e as categorias de vinculação.
- O resumo e os resultados legíveis por máquina de cada execução para o engine 2.1.1 (todas as medidas e a caracterização da memória da sessão), o engine 2.0.1 (velocidade e memória, memória da sessão), o Holarch 2.15.1 (os dois builds do código do engine 2.0.0), 2.14.0 (velocidade e memória), 2.13.1 e 2.12.0, e os tempos WebAssembly e a memória da sessão medidos no Safari.
- O gerador dos modelos grandes, determinístico por semente, e os scripts de medição e comparação.
- Um checksum de cada arquivo.
Ele não contém o engine nem os arquivos do OMG. Os scripts obtêm os modelos de exemplo e a implementação piloto de suas fontes públicas no commit fixado e com o checksum do pacote. O engine para uma nova execução vem com uma avaliação do engine.
Execuções anteriores
As execuções oficiais anteriores permanecem como foram medidas, cada uma sob sua própria versão do método. Nos métodos 1 a 3, a análise a frio em até 0,6 s com 100.000 linhas era uma meta; nenhuma execução a atendeu. O método 4 a informa sem meta. O pico de memória antes da versão 3 do método era o pico de memória residente do processo de medição, que também conta a memória que o alocador guarda para reutilização; ele não é comparável com o número do heap do engine. As execuções do Holarch 2.15.0 e 2.14.0 mediram apenas velocidade e memória; os tempos da execução 2.15.0 são cerca de um quarto mais altos que os dos builds anteriores e posteriores a ela, medidos enquanto outros trabalhos rodavam no mesmo computador.
| Build | Versão do engine | Versão do Holarch | Método | Aceitação, bruta | Aceitação, classificada (revisão interna) | Vinculação de nomes | Análise a frio, 100.000 linhas | Pico de memória, 100.000 linhas |
|---|---|---|---|---|---|---|---|---|
| 37168cc | 2.1.1 | 2.21.0 (distribui o engine 2.1.2) | 10 | 242 de 252 | 252 de 252 | 4.904 de 4.908 | 1,43 s | 302 MiB de heap do engine |
| d8cf5c8 | 2.0.1 | 2.17.1 | 7 | Não medido | Não medido | Não medido | 1,23 s | 362 MiB de heap do engine |
| 91f058a | 2.0.0 | 2.15.1 (mesmo código de engine que dd4fb10) | 6 | 232 de 252 | 241 de 241 | 4.879 de 4.886 | 1,35 s | 362 MiB de heap do engine |
| dd4fb10 | 1.0.0 | 2.15.1 | 6 | 232 de 252 | 241 de 241 | 4.879 de 4.886 | 1,28 s | 362 MiB de heap do engine |
| e6bb924 | 1.0.0 | 2.15.0 | 5 | Não medido | Não medido | Não medido | 1,57 s | 362 MiB de heap do engine |
| 0c983e2 | 1.0.0 | 2.14.0 | 6 | Não medido | Não medido | Não medido | 1,37 s | 362 MiB de heap do engine |
| d3f5d4b | 1.0.0 | 2.13.1, 2.13.2 | 5 | 231 de 252 | 240 de 242 | 4.851 de 4.860 | 1,24 s | 362 MiB de heap do engine |
| 8a6bf7b | 1.0.0 | 2.12.0 | 5 | 220 de 252 | 229 de 242 | 4.753 de 4.768 | 1,21 s | 362 MiB de heap do engine |
| 6eec2b7 | 1.0.0 | – | 5 | 231 de 252 | 240 de 240 (classificação anterior à revisão de erros) | 4.851 de 4.860 | 1,20 s | 362 MiB de heap do engine |
| c184e57 | 1.0.0 | 2.11.0 | 3 | 220 de 252 | 228 de 228 | 4.753 de 4.768 | 1,31 s | 361 MiB de heap do engine |
| bfa03c7 | 1.0.0 | – | 2 | 220 de 252 | 228 de 228 | 4.753 de 4.768 | 1,35 s | 972 MiB de processo |
| 1cada39 | 1.0.0 | – | 2 | 216 de 252 | 224 de 228 | 4.737 de 4.752 | 4,24 s | 1.022 MiB de processo |
| fd20280 | 1.0.0 | – | 1 | 145 de 252 | Não classificada (método 1) | 4.326 de 4.373 | 2,41 s | 1.535 MiB de processo |
O que estes resultados não mostram
- Estas são medições do próprio Holarch nos modelos em que foram executadas. Não são uma certificação. O Object Management Group não as revisou nem endossou.
- A implementação piloto e os modelos de exemplo não são a especificação. Onde eles e o engine divergem, a classificação acima diz qual lado a especificação sustenta, e por quê.
- Cada classificação e revisão desta página é uma revisão interna. Está planejada uma revisão externa de uma amostra dos casos de teste do engine em relação à especificação.
- A simulação de ações e máquinas de estados, o complemento de simulação licenciado separadamente, não é medida aqui.
- A conversão de modelos SysML v1 para SysML v2 não é medida aqui. Para os licenciados do engine, ela é o complemento de migração, licenciado separadamente.
Experimente o engine nos seus próprios modelos.
A avaliação é gratuita por 60 dias.