Skip to content

Desempenho

PedroVMota edited this page Nov 13, 2026 · 2 revisions

Desempenho

O desempenho é a primeira prioridade do projeto: a interface nunca pode engasgar ao fazer zoom, pan ou ao manipular muitos objetos, e a simulação nunca bloqueia a interface.

Decisões de desenho

Decisão Efeito
Simulador numa thread própria, comunicação por canal + ArcSwap A UI nunca espera por um lock; leitura do snapshot wait-free.
Edições como Edit repetidas na UI e no simulador Nunca se clona nem partilha o circuito inteiro; a edição aparece no próprio frame.
Cena com slots estáveis, atualizada no lugar Mover um componente envia algumas centenas de bytes para a GPU, não 11 MB.
Culling na GPU (compute shader) + draw_indirect por tipo Número constante de chamadas de desenho; a CPU não faz trabalho por objeto ao navegar.
Atlas de símbolos estático, construído uma vez Mudar de estilo ANSI/IEC só altera um uniform; estado (LED, interruptor, relógio) vem dos níveis, sem mudar malhas.
Níveis a 2 bits por slot de sinal 16 sinais por palavra num storage buffer.
Streaming de cenas novas em fatias de 1 MiB Abrir um circuito grande não bloqueia nenhum frame.
Construção e libertação de cenas na thread bw-scene Libertar 460k instâncias e a R-tree não custa à UI.
Edições de fios locais (adjacência dos nós tocados) Nada é O(total de fios): apagar um componente com 100k custa ≈0,003 ms (antes ≈0,6 ms).
Recompilação agrupada; edições geométricas não recompilam O simulador recompila uma vez por lote, em fundo.
Hierarquia achatada na compilação, templates em cache por hash Simular macros não tem custo de hierarquia; editar uma definição só reconstrói o necessário.
Repaint a pedido 0 % de CPU em repouso; com a janela tapada, redesenhos espaçados de ≥ 250 ms.
Janela de memória virtualizada, feed próprio a ≤ 100 ms 16K palavras custam o mesmo que 16; custo zero com a janela fechada.

Testes de carga

Teste Conteúdo
--stress (⇧⌘T) 100 160 componentes, 598 143 segmentos e 79 502 junções: ≈778 mil instâncias na GPU. Fios ortogonais com fan-out por junções.
--stress-macros 2 500 células "contador de 4 bits → somador de 4 bits" em 50 por linha: 37 500 instâncias em quatro níveis, 70 150 primitivas.

Medição reprodutível (--stress --sweep)

bitwerk --stress --sweep [--sweep-csv frames.csv] [--window-pos X,Y] (ou make sweep) carrega o teste de carga e, quando a cena está toda na GPU, corre um guião de ≈20 s:

  1. repouso com tudo visível;
  2. zoom até 40 pt/unidade, pan, zoom de volta;
  3. 200 edições (uma por frame, em ciclos de oito: mover um componente, rodá-lo, adicionar um NOT, ligar um ramo a meio de um segmento, arrastar um segmento, mover uma curva, apagar um segmento, apagar o NOT);
  4. repouso.

No fim imprime uma tabela por fase (média, p50, p95, p99 e máximo do intervalo entre frames, frames > 16,7 ms e > 20 ms, vsyncs perdidos estimados, CPU por frame, tempo de prepare) e a latência edição → ecrã, e fecha. A janela fica sempre por cima. A taxa de refresh é detetada pela mediana dos intervalos. Se algum frame não foi apresentado (janela tapada, ecrã bloqueado) o resumo diz INVALID RUN.

Resultados

Medidos num MacBook Pro M1 Pro, monitor externo a 60 Hz, --release.

Sweep com janela (última corrida válida documentada)

Teste Intervalo p99 Máx vsyncs perdidos Edição → ecrã
--stress --sweep (≈778k instâncias) 19,3 ms 25,8 ms (pico único) 0 ≈1,3 ms (no próprio frame)
--stress-macros --sweep (37 500 instâncias) 19,4 ms 21,2 ms 0 ≈0,4 ms (0,42 ms)

A 60 Hz o período é 16,7 ms; o jitter de ±3 ms observado vem do ritmo de apresentação do macOS (nextDrawable) e quase nunca resulta num vsync perdido. Valores do sweep válido feito depois do importador do Digital Works (24 buckets, cores e mostradores); a versão anterior medida na mesma sessão deu p99 19,5 / 19,2 ms, ou seja, sem regressão.

Evolução (antes → depois da cena incremental e do culling na GPU)

Métrica Antes Depois
CPU por frame p99 / máx 21–22 / 40–63 ms 2,8 / 3,8–8,7 ms
200 edições: intervalo p99 28–29 ms 17,1–18,0 ms
Latência edição → ecrã 225–232 ms (13 frames) 1,3 ms (0 frames)
Pior frame a carregar a cena ≈60 ms (11 MB num frame) ≤ 17 ms por frame
Repouso sem alterações um núcleo a 100 % 0 % de CPU

make bench (offscreen, MSAA 4×, cena de 100k)

Caso 1× 2×
Tudo visível (fit) ≈4,7 ms ≈4,8 ms
2× zoom de ajuste ≈2,6 ms ≈2,8 ms
4 pt/unidade 0,70 ms 1,19 ms
30 pt/unidade 0,61 ms 0,85 ms
Frame de edição (mover) 1,18 ms 1,44 ms
Níveis novos em todas as redes a cada frame ≈0,36 ms —

Outras medições do modelo: edições de fios (dividir + ramo, arrastar, apagar) ≈0,005 ms por edição (modelo + cena); construção completa da cena em fundo ≈135–150 ms; streaming de 18 fatias com o pior frame ≈8,6 ms.

Simulador

Teste Resultado
stress_sim_cost (100k componentes) Compilação + estabilização ≈31 ms; um tick ≈12–13 µs
stress_macros_cost (70 000 primitivas, 10 000 flip-flops a contar) Compilação a frio ≈16 ms (achatamento ≈13 ms, netlist ≈3,5 ms); estabilização 2,4 ms; tick ≈160 µs
Recompilar depois de uma edição na raiz (macros) ≈14,8 ms (todos os templates reutilizados)
Redefinir o meio somador (20 000 instâncias aninhadas) Modelo na UI 0,03 ms; recompilação ≈14,8 ms (4 templates reconstruídos)
Redefinir a célula com um pino novo (2 500 instâncias mudam de forma) Modelo 2,4 ms; modelo + cena 7,5 ms, no próprio frame
sim_bench_flip_flops_and_memory (512 contadores JK + RAM, 6658 componentes) ≈19 000 ticks/s (52 µs por tick)

Todas as compilações correm na thread do simulador, sem efeito nos frames.

Importação do Digital Works

Micro 5.dwm (5,1 MB, 408 mil objetos) importa em ≈143 ms; importar a pasta inteira do pacote para a biblioteca demora ≈1,5 s.

Exportação para o Digital Works

  • Micro 5.dwm (408 mil objetos) exporta em ≈125 ms (construção do grafo, escrita e releitura de verificação).
  • A exportação corre numa thread própria (bw-dw-export) com uma cópia partilhada (Arc) do circuito, por isso não afeta os frames; o relatório mostra o tempo de cada exportação.
  • O teste stress_circuit_exports (bw-io/tests/dwm_export.rs) exporta o teste de carga com 20 mil componentes e imprime o tempo (--nocapture); não há valor de referência registado.

Como medir

make bench                                   # offscreen, sem janela
make sweep                                   # = --stress --sweep (abre uma janela)
cargo run --release -p bw-app -- --stress-macros --sweep
cargo test --release -p bw-app -- --ignored --nocapture stress_sim_cost
cargo test --release -p bw-app -- --ignored --nocapture stress_macros_cost

Para um resultado válido, o ecrã não pode estar bloqueado nem a janela tapada.

Limitações conhecidas

  • O simulador recompila a netlist inteira a cada lote de edições (≈20–30 ms para 100k componentes, em fundo); as cores das partes editadas chegam com esse atraso, a geometria aparece logo.
  • Com tudo visível a GPU desenha cada instância; ainda não há um LOD agregado para zoom muito afastado.
  • No arranque, o primeiro frame gasta ≈28 ms de CPU (atlas de fontes do egui) e o seguinte espera ≈100 ms pela primeira apresentação da janela.
  • O atlas de símbolos ocupa ≈6 MiB na GPU.
  • Editar dentro de uma macro clona o corpo da definição a cada edição (barato para macros normais).
  • As malhas das anotações são construídas de uma vez quando a cena aparece (2000 anotações: um frame de ≈18 ms).

Clone this wiki locally