Tempos medidos do motor do sgcPivotGrid, TsgcPivotEngine, com 1.000.000 e 10.000.000 de linhas: a carga dos dados, o recálculo de três layouts de pivot em uma única passagem e com cálculo paralelo, e a memória que o motor acrescenta aos dados. Cada número vem de um programa de benchmark dos demos do sgcUI, e você pode executar o mesmo teste no seu próprio hardware.
AppendRowWin64, Delphi 13, mediana de 5 execuções após 1 execução de aquecimento, na máquina de teste descrita abaixo. Vá para os resultados Win64, os resultados Win32, os orçamentos do QA ou como executar o teste você mesmo.
As linhas são geradas a partir de uma semente fixa, de modo que todas as máquinas calculam o mesmo pivot. Cada modo verifica que o total geral de P1 é igual à soma da coluna de valores.
| Cenário | O que o programa faz |
|---|---|
| Carga | AppendRow de 1.000.000 ou 10.000.000 de linhas, cada uma com 3 valores de texto, 1 número e 1 data. O texto é codificado em índices de membros à medida que chega. Uma segunda etapa preenche uma coluna numérica com 100.000 valores distintos por meio de Store.SetFloat. |
| P1 Sum | 2 campos de linha (50 regiões por 20 produtos, 1.051 itens de linha com os subtotais e o total geral) e 1 campo de coluna (12 meses), Sum de um valor. O pivot básico. |
| P3 CountDistinct | O layout P1 contando os valores distintos da coluna com 100.000 valores distintos, o agregado padrão mais caro. |
| P4 StdDev, Average, Max | Três medidas ao mesmo tempo no layout P1. |
| Passagem única | O motor padrão, com ParallelCalculation desativado. |
| 1 a 14 threads | ParallelCalculation := True com MaxThreads definido e ParallelThreshold := 1, de modo que 1.000.000 de linhas também são executadas em paralelo. "Todas as CPUs" é MaxThreads := 0, uma thread por CPU lógica, 14 na máquina de teste. |
| Memória do motor | A memória que o motor aloca além dos dados carregados para P1 (gate M1 do QA). A memória do store são os próprios dados carregados. |
Uma estação de trabalho de desenvolvedor com a sua carga normal de desktop, não uma máquina de laboratório isolada. Medido em 4 de novembro de 2026.
| Item | Valor |
|---|---|
| CPU | Intel Core Ultra 5 245T, um processador de desktop de 35 W |
| Núcleos | 6 núcleos de desempenho e 8 núcleos eficientes, 14 CPUs lógicas |
| Memória | 31,5 GB |
| Sistema operacional | Windows 11 Pro 26H2 (build 26300) |
| Compilador | Delphi 13 Florence, build de release: otimização ativada, verificações de intervalo e de overflow desativadas |
| Plataformas | Win64 (mediana de 5 execuções após 1 execução de aquecimento) e Win32 (execução rápida: 1 execução cronometrada após 1 execução de aquecimento) |
| sgcPivotGrid | 2026.11.0 Registrada |
O processador mistura núcleos rápidos e eficientes, e o Windows decide onde cada thread de trabalho é executada. Com 8 threads ou mais, parte do trabalho vai para os núcleos eficientes: P4 com 1.000.000 de linhas em Win64 alterna então entre execuções de cerca de 13 ms e de cerca de 32 ms, e por isso a sua mediana salta para 31,2 ms com 8 threads.
Mediana de 5 execuções após 1 execução de aquecimento. Tempos em milissegundos.
| Carga e memória | 1.000.000 de linhas | 10.000.000 de linhas |
|---|---|---|
AppendRow, colunas de 3 textos, 1 float e 1 data | 132,9 ms | 1.384,0 ms |
Store.SetFloat, 1 coluna float com 100.000 valores distintos | 8,6 ms | 98,3 ms |
| Memória do store (6 colunas) | 36,0 MB | 576,0 MB |
| Memória do motor após P1, em todos os modos | 4,8 MB | 39,1 MB |
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 13,9 ms | 25,6 ms | 26,3 ms |
| Paralelo, 1 thread | 1 | 12,2 ms | 21,6 ms | 26,3 ms |
| Paralelo, 2 threads | 2 | 9,6 ms | 18,2 ms | 17,8 ms |
| Paralelo, 4 threads | 4 | 7,1 ms | 15,9 ms | 12,9 ms |
| Paralelo, 8 threads | 8 | 6,8 ms | 15,3 ms | 31,2 ms |
| Paralelo, todas as CPUs | 14 | 6,8 ms | 16,5 ms | 31,8 ms |
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 121,1 ms | 300,2 ms | 216,9 ms |
| Paralelo, 1 thread | 1 | 106,4 ms | 253,0 ms | 230,6 ms |
| Paralelo, 2 threads | 2 | 67,1 ms | 212,7 ms | 130,3 ms |
| Paralelo, 4 threads | 4 | 46,9 ms | 184,6 ms | 127,5 ms |
| Paralelo, 8 threads | 8 | 63,6 ms | 181,1 ms | 111,9 ms |
| Paralelo, todas as CPUs | 14 | 73,5 ms | 186,4 ms | 105,4 ms |
Execução rápida: 1 execução cronometrada após 1 execução de aquecimento, de modo que estes números têm mais ruído do que as medianas de Win64. O programa é large address aware, o que o store de 10.000.000 de linhas exige.
| Carga e memória | 1.000.000 de linhas | 10.000.000 de linhas |
|---|---|---|
AppendRow, colunas de 3 textos, 1 float e 1 data | 143,7 ms | 1.511,9 ms |
Store.SetFloat, 1 coluna float com 100.000 valores distintos | 16,8 ms | 183,7 ms |
| Memória do store (6 colunas) | 36,0 MB | 576,0 MB |
| Memória do motor após P1, em todos os modos | 4,7 MB | 39,1 MB |
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 16,9 ms | 27,3 ms | 50,8 ms |
| Paralelo, 1 thread | 1 | 16,7 ms | 22,9 ms | 51,0 ms |
| Paralelo, 2 threads | 2 | 11,3 ms | 20,4 ms | 32,8 ms |
| Paralelo, 4 threads | 4 | 8,6 ms | 16,3 ms | 23,1 ms |
| Paralelo, 8 threads | 8 | 8,5 ms | 16,3 ms | 19,2 ms |
| Paralelo, todas as CPUs | 14 | 8,5 ms | 15,6 ms | 19,2 ms |
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 143,6 ms | 286,8 ms | 442,6 ms |
| Paralelo, 1 thread | 1 | 139,4 ms | 253,6 ms | 463,7 ms |
| Paralelo, 2 threads | 2 | 88,0 ms | 207,8 ms | 252,4 ms |
| Paralelo, 4 threads | 4 | 52,5 ms | 176,8 ms | 141,7 ms |
| Paralelo, 8 threads | 8 | 57,2 ms | 167,1 ms | 159,6 ms |
| Paralelo, todas as CPUs | 14 | 64,4 ms | 172,0 ms | 131,9 ms |
A versão .NET do programa de benchmark, com as mesmas linhas, os mesmos layouts e os mesmos modos do programa Delphi. Ela é executada em outro runtime, portanto leia estes números como uma tabela à parte. Mediana de 5 execuções após 1 execução de aquecimento. Tempos em milissegundos.
| Carga e memória | 1.000.000 de linhas | 10.000.000 de linhas |
|---|---|---|
AppendRow, colunas de 3 textos, 1 float e 1 data | 75,6 ms | 770,4 ms |
Store.SetFloat, 1 coluna float com 100.000 valores distintos | 2,9 ms | 43,0 ms |
| Memória do store (6 colunas) | 36,0 MB | 576,0 MB |
| Memória do motor após P1, em todos os modos | 4,7 MB | 39,1 MB |
Runtime: .NET 8.0.31, processo x64, build de release, um programa de console net8.0 com o sgcPivotGrid 2026.11.0 Registrada, na máquina de teste acima e no mesmo dia. A memória é o heap gerenciado ativo, medido com GC.GetTotalMemory(true) após uma coleta completa.
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 11,9 ms | 23,3 ms | 14,7 ms |
| Paralelo, 1 thread | 1 | 12,1 ms | 21,3 ms | 20,1 ms |
| Paralelo, 2 threads | 2 | 8,5 ms | 15,5 ms | 12,6 ms |
| Paralelo, 4 threads | 4 | 6,3 ms | 14,8 ms | 9,9 ms |
| Paralelo, 8 threads | 8 | 6,8 ms | 13,6 ms | 9,8 ms |
| Paralelo, todas as CPUs | 14 | 6,6 ms | 13,3 ms | 9,6 ms |
| Modo | Threads | P1 Sum | P3 CountDistinct | P4 StdDev, Average, Max |
|---|---|---|---|---|
| Passagem única | 1 | 67,6 ms | 275,1 ms | 128,0 ms |
| Paralelo, 1 thread | 1 | 76,4 ms | 215,0 ms | 175,9 ms |
| Paralelo, 2 threads | 2 | 44,2 ms | 159,6 ms | 89,9 ms |
| Paralelo, 4 threads | 4 | 28,8 ms | 133,7 ms | 56,2 ms |
| Paralelo, 8 threads | 8 | 34,0 ms | 151,7 ms | 72,6 ms |
| Paralelo, todas as CPUs | 14 | 28,3 ms | 154,9 ms | 66,0 ms |
Os testes de desempenho do QA do .NET usam os orçamentos do Delphi multiplicados por 1,2 (P1 120 ms em x64). Todos os gates com 1.000.000 de linhas ficaram dentro do orçamento nesta execução, e o total geral de P1 foi igual à soma dos valores em todos os modos.
PivotGrid\Benchmark\Benchmark.csproj a partir dos demos .NET do sgcUI. O README.md dessa pasta traz os detalhes.dotnet-<arch>.md, .json e .csv, por exemplo dotnet-x64.md.dotnet run -c Release
dotnet run -c Release -- --rows=1m,10m --quick
dotnet run -c Release -- --rows=500k,2m --threads=4 --out=C:\benchO grupo de desempenho do QA verifica estes orçamentos a cada build, em Win64 e em Win32, e a execução do QA falha quando um deles é excedido. 10.000.000 de linhas não têm orçamento: o QA apenas as reporta.
| Gate | O que é medido | Orçamento Win64 | Medido em Win64 | Orçamento Win32 | Medido em Win32 |
|---|---|---|---|---|---|
| P1 | Recalcular 1.000.000 de linhas, 2 campos de linha, 1 campo de coluna, 1 Sum | 100 ms | 13,9 ms | 160 ms | 16,9 ms |
| P1P | P1 com ParallelCalculation, uma thread por CPU | 100 ms | 6,8 ms | 160 ms | 8,5 ms |
| P2 | AppendRow de 1.000.000 de linhas com 3 textos, 1 float e 1 data, codificação incluída | 900 ms | 132,9 ms | 1.400 ms | 143,7 ms |
| P3 | O layout P1 com CountDistinct em uma coluna com 100.000 valores distintos | 400 ms | 25,6 ms | 600 ms | 27,3 ms |
| P4 | O layout P1 com StdDev, Average e Max | 180 ms | 26,3 ms | 280 ms | 50,8 ms |
| M1 | Memória do motor além do store para P1 | 32 MB | 4,8 MB | 32 MB | 4,7 MB |
| M1P | M1 com ParallelCalculation, uma thread por CPU | 32 MB | 4,8 MB | 32 MB | 4,7 MB |
Os orçamentos são deliberadamente folgados, para que detectem regressões em máquinas de build lentas. Na máquina de teste, os valores medidos ficam entre 5,5 e 22 vezes abaixo deles.
O que as linhas paralelas das tabelas acrescentam e quantas threads usar. Registrada
ParallelCalculation := True divide um recálculo grande em blocos fixos de 131.072 linhas, calcula os blocos em threads de trabalho e os combina na ordem dos blocos. MaxThreads limita os threads de trabalho (0 é uma thread por CPU, no máximo 64), e ParallelThreshold, 1.000.000 de linhas por padrão, mantém os stores menores na passagem única. Vem desativado por padrão, porque Sum, Average, Product e a família StdDev podem diferir da passagem única nos últimos bits. Está nas edições Registrada e de Avaliação.
MaxThreads de 4 a 8. Na máquina de teste, 4 threads deram o melhor P1 nos dois tamanhos em Win64: 7,1 ms com 1.000.000 de linhas e 46,9 ms com 10.000.000 de linhas, contra 13,9 ms e 121,1 ms em uma única passagem.O mesmo programa, as mesmas linhas e os mesmos layouts no seu próprio hardware.
Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr a partir dos demos do sgcUI. O README.txt dessa pasta traz os detalhes.sgcPivotGridBenchmark [--rows=1m,10m] [--threads=1,2,4,8,0] [--out=folder] [--quick]
sgcPivotGridBenchmark
sgcPivotGridBenchmark --rows=1m,10m --quick
sgcPivotGridBenchmark --rows=500k,2m --threads=4 --out=C:\bench| Opção | Significado |
|---|---|
--rows | Quantidades de linhas a testar, com os sufixos k e m. |
--threads | Valores de MaxThreads para os modos paralelos. 0 ou all é uma thread por CPU. A passagem única sempre é executada. |
--out | Pasta de saída, por padrão uma pasta benchmark ao lado do exe. |
--quick | 1 execução cronometrada após o aquecimento, em vez da mediana de 5. |
Cada execução grava delphi-<platform>.md, .json e .csv com a máquina, as configurações e cada tempo, e verifica os orçamentos do QA com 1.000.000 de linhas. BenchmarkMain.pas concentra toda a lógica, de modo que você pode trocar as linhas geradas pelos seus próprios dados e manter a mesma medição de tempo e os mesmos relatórios. Se os seus números forem muito diferentes destes, avise-nos.
Os orçamentos do QA também estão documentados no tópico de ajuda Architecture.