sgcPivotGrid Pruebas de rendimiento

Tiempos medidos del motor de sgcPivotGrid, TsgcPivotEngine, con 1,000,000 y 10,000,000 de filas: carga de los datos, recálculo de tres diseños de tabla dinámica en una sola pasada y con cálculo en paralelo, y la memoria que el motor añade a los datos. Cada cifra procede de un programa de pruebas incluido en las demos de sgcUI, así que puedes ejecutar la misma prueba en tu propio equipo.

13.9 ms
Recalcular 1,000,000 de filas, Sum, una sola pasada
121.1 ms
Recalcular 10,000,000 de filas, Sum, una sola pasada
46.9 ms
10,000,000 de filas, Sum, cálculo en paralelo con 4 hilos
1,384.0 ms
Cargar 10,000,000 de filas con AppendRow

Win64, Delphi 13, mediana de 5 ejecuciones tras 1 ejecución de calentamiento, en el equipo de pruebas descrito más abajo. Ir a los resultados Win64, los resultados Win32, los presupuestos de QA o cómo ejecutar la prueba tú mismo.

Método

Qué se mide

Las filas se generan a partir de una semilla fija, así que todos los equipos calculan la misma tabla dinámica. Cada modo comprueba que el total general de P1 es igual a la suma de la columna de valores.

EscenarioQué hace el programa
CargaAppendRow de 1,000,000 o 10,000,000 de filas con 3 valores de texto, 1 número y 1 fecha cada una. El texto se codifica en índices de miembro a medida que llega. Un segundo paso llena una columna numérica con 100,000 valores distintos mediante Store.SetFloat.
P1 Sum2 campos de fila (50 regiones por 20 productos, 1,051 elementos de fila con los subtotales y el total general) y 1 campo de columna (12 meses), Sum de un valor. La tabla dinámica básica.
P3 CountDistinctEl diseño P1 contando los valores distintos de la columna con 100,000 valores distintos, la agregación estándar más costosa.
P4 StdDev, Average, MaxTres medidas a la vez sobre el diseño P1.
Una sola pasadaEl motor por defecto, con ParallelCalculation desactivado.
De 1 a 14 hilosParallelCalculation := True con MaxThreads definido y ParallelThreshold := 1, de modo que también 1,000,000 de filas se ejecutan en paralelo. "Todas las CPU" es MaxThreads := 0, un hilo por CPU lógica, 14 en el equipo de pruebas.
Memoria del motorLa memoria que el motor reserva además de los datos cargados para P1 (puerta de QA M1). La memoria del almacén son los propios datos cargados.
Hardware

Equipo de pruebas

Una estación de trabajo de desarrollo con su carga de escritorio habitual, no un equipo de laboratorio aislado. Medido el 4 de noviembre de 2026.

ElementoValor
CPUIntel Core Ultra 5 245T, un procesador de escritorio de 35 W
Núcleos6 núcleos de rendimiento y 8 núcleos eficientes, 14 CPU lógicas
Memoria31.5 GB
Sistema operativoWindows 11 Pro 26H2 (compilación 26300)
CompiladorDelphi 13 Florence, compilación release: optimización activada, comprobaciones de rango y de desbordamiento desactivadas
PlataformasWin64 (mediana de 5 ejecuciones tras 1 ejecución de calentamiento) y Win32 (ejecución rápida: 1 ejecución medida tras 1 ejecución de calentamiento)
sgcPivotGrid2026.11.0 Registrada

El procesador mezcla núcleos rápidos y eficientes, y Windows decide dónde se ejecuta cada hilo de trabajo. Con 8 hilos o más parte del trabajo cae en los núcleos eficientes: P4 con 1,000,000 de filas en Win64 alterna entonces entre ejecuciones de unos 13 ms y de unos 32 ms, así que su mediana salta a 31.2 ms con 8 hilos.

Resultados

Win64

Mediana de 5 ejecuciones tras 1 ejecución de calentamiento. Tiempos en milisegundos.

Carga y memoria1,000,000 de filas10,000,000 de filas
AppendRow, columnas de 3 de texto, 1 float, 1 fecha132.9 ms1,384.0 ms
Store.SetFloat, 1 columna float con 100,000 valores distintos8.6 ms98.3 ms
Memoria del almacén (6 columnas)36.0 MB576.0 MB
Memoria del motor tras P1, en cualquier modo4.8 MB39.1 MB

Recálculo, 1,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada113.9 ms25.6 ms26.3 ms
Paralelo, 1 hilo112.2 ms21.6 ms26.3 ms
Paralelo, 2 hilos29.6 ms18.2 ms17.8 ms
Paralelo, 4 hilos47.1 ms15.9 ms12.9 ms
Paralelo, 8 hilos86.8 ms15.3 ms31.2 ms
Paralelo, todas las CPU146.8 ms16.5 ms31.8 ms

Recálculo, 10,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada1121.1 ms300.2 ms216.9 ms
Paralelo, 1 hilo1106.4 ms253.0 ms230.6 ms
Paralelo, 2 hilos267.1 ms212.7 ms130.3 ms
Paralelo, 4 hilos446.9 ms184.6 ms127.5 ms
Paralelo, 8 hilos863.6 ms181.1 ms111.9 ms
Paralelo, todas las CPU1473.5 ms186.4 ms105.4 ms
Resultados

Win32

Ejecución rápida: 1 ejecución medida tras 1 ejecución de calentamiento, así que estas cifras tienen más ruido que las medianas de Win64. El programa es large address aware, algo que necesita el almacén de 10,000,000 de filas.

Carga y memoria1,000,000 de filas10,000,000 de filas
AppendRow, columnas de 3 de texto, 1 float, 1 fecha143.7 ms1,511.9 ms
Store.SetFloat, 1 columna float con 100,000 valores distintos16.8 ms183.7 ms
Memoria del almacén (6 columnas)36.0 MB576.0 MB
Memoria del motor tras P1, en cualquier modo4.7 MB39.1 MB

Recálculo, 1,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada116.9 ms27.3 ms50.8 ms
Paralelo, 1 hilo116.7 ms22.9 ms51.0 ms
Paralelo, 2 hilos211.3 ms20.4 ms32.8 ms
Paralelo, 4 hilos48.6 ms16.3 ms23.1 ms
Paralelo, 8 hilos88.5 ms16.3 ms19.2 ms
Paralelo, todas las CPU148.5 ms15.6 ms19.2 ms

Recálculo, 10,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada1143.6 ms286.8 ms442.6 ms
Paralelo, 1 hilo1139.4 ms253.6 ms463.7 ms
Paralelo, 2 hilos288.0 ms207.8 ms252.4 ms
Paralelo, 4 hilos452.5 ms176.8 ms141.7 ms
Paralelo, 8 hilos857.2 ms167.1 ms159.6 ms
Paralelo, todas las CPU1464.4 ms172.0 ms131.9 ms
Resultados

.NET x64

El port a .NET del programa de pruebas, con las mismas filas, diseños y modos que el programa Delphi. Se ejecuta en otro runtime, así que lee estas cifras como una tabla propia. Mediana de 5 ejecuciones tras 1 ejecución de calentamiento. Tiempos en milisegundos.

Carga y memoria1,000,000 de filas10,000,000 de filas
AppendRow, columnas de 3 de texto, 1 float, 1 fecha75.6 ms770.4 ms
Store.SetFloat, 1 columna float con 100,000 valores distintos2.9 ms43.0 ms
Memoria del almacén (6 columnas)36.0 MB576.0 MB
Memoria del motor tras P1, en cualquier modo4.7 MB39.1 MB

Runtime: .NET 8.0.31, proceso x64, compilación release, un programa de consola net8.0 con sgcPivotGrid 2026.11.0 Registrada, en el equipo de pruebas anterior y el mismo día. La memoria es el montón administrado vivo, medido con GC.GetTotalMemory(true) tras una recolección completa.

Recálculo, 1,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada111.9 ms23.3 ms14.7 ms
Paralelo, 1 hilo112.1 ms21.3 ms20.1 ms
Paralelo, 2 hilos28.5 ms15.5 ms12.6 ms
Paralelo, 4 hilos46.3 ms14.8 ms9.9 ms
Paralelo, 8 hilos86.8 ms13.6 ms9.8 ms
Paralelo, todas las CPU146.6 ms13.3 ms9.6 ms

Recálculo, 10,000,000 de filas

ModoHilosP1 SumP3 CountDistinctP4 StdDev, Average, Max
Una sola pasada167.6 ms275.1 ms128.0 ms
Paralelo, 1 hilo176.4 ms215.0 ms175.9 ms
Paralelo, 2 hilos244.2 ms159.6 ms89.9 ms
Paralelo, 4 hilos428.8 ms133.7 ms56.2 ms
Paralelo, 8 hilos834.0 ms151.7 ms72.6 ms
Paralelo, todas las CPU1428.3 ms154.9 ms66.0 ms

Las pruebas de rendimiento de QA de .NET usan los presupuestos de Delphi multiplicados por 1.2 (P1 120 ms en x64). Todas las puertas con 1,000,000 de filas quedaron dentro de su presupuesto en esta ejecución, y el total general de P1 fue igual a la suma de los valores en todos los modos.

Ejecuta la prueba de .NET

  1. Abre PivotGrid\Benchmark\Benchmark.csproj desde las demos .NET de sgcUI. El README.md de esa carpeta tiene los detalles.
  2. Compílalo y ejecútalo en Release con el SDK de .NET 8 o posterior. Los modos de cálculo en paralelo necesitan la edición Registrada o de prueba.
  3. Las opciones son las del programa Delphi. Cada ejecución escribe dotnet-<arch>.md, .json y .csv, por ejemplo 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:\bench
Calidad

Presupuestos de QA con 1,000,000 de filas

El grupo de rendimiento de QA comprueba estos presupuestos en cada compilación, en Win64 y en Win32, y la ejecución de QA falla cuando no se cumple alguno. Los 10,000,000 de filas no tienen presupuesto: QA solo los informa.

PuertaQué se midePresupuesto Win64Medido Win64Presupuesto Win32Medido Win32
P1Recalcular 1,000,000 de filas, 2 campos de fila, 1 campo de columna, 1 Sum100 ms13.9 ms160 ms16.9 ms
P1PP1 con ParallelCalculation, un hilo por CPU100 ms6.8 ms160 ms8.5 ms
P2AppendRow de 1,000,000 de filas de 3 valores de texto, 1 float y 1 fecha, con la codificación incluida900 ms132.9 ms1,400 ms143.7 ms
P3El diseño P1 con CountDistinct en una columna con 100,000 valores distintos400 ms25.6 ms600 ms27.3 ms
P4El diseño P1 con StdDev, Average y Max180 ms26.3 ms280 ms50.8 ms
M1Memoria del motor por encima del almacén para P132 MB4.8 MB32 MB4.7 MB
M1PM1 con ParallelCalculation, un hilo por CPU32 MB4.8 MB32 MB4.7 MB

Los presupuestos son holgados a propósito, para detectar regresiones en equipos de compilación lentos. En el equipo de pruebas los valores medidos quedan entre 5.5 y 22 veces por debajo de ellos.

Hilos

Cálculo en paralelo

Qué añaden las filas paralelas de las tablas y cuántos hilos usar. Registrada

ParallelCalculation := True divide un recálculo grande en bloques fijos de 131,072 filas, calcula los bloques en hilos de trabajo y los combina en el orden de los bloques. MaxThreads limita los hilos de trabajo (0 es uno por CPU, como máximo 64), y ParallelThreshold, 1,000,000 de filas por defecto, mantiene los almacenes más pequeños en la pasada única. Está desactivado por defecto, porque Sum, Average, Product y la familia StdDev pueden diferir de la pasada única en los últimos bits. Está en las ediciones Registrada y de prueba.

  • Usa MaxThreads de 4 a 8. En el equipo de pruebas, 4 hilos dieron el mejor P1 con ambos tamaños en Win64: 7.1 ms con 1,000,000 de filas y 46.9 ms con 10,000,000 de filas, frente a 13.9 ms y 121.1 ms en una sola pasada.
  • Más hilos no siempre es más rápido. 1,000,000 de filas son solo 8 bloques, así que el coste de arrancar hilos y de combinar pesa más que el trabajo ahorrado. Con 10,000,000 de filas P1 tarda 73.5 ms con 14 hilos frente a 46.9 ms con 4, porque la combinación ordenada se ejecuta en serie.
  • Las medidas más pesadas escalan más. P4 con 10,000,000 de filas sigue mejorando hasta 14 hilos en Win64: 105.4 ms frente a 216.9 ms en una sola pasada.
  • CountDistinct es el que menos gana. Su recuento de valores distintos se ejecuta en serie, así que P3 es como mucho unas 1.6 veces más rápido.
Reproducir

Ejecuta la prueba tú mismo

El mismo programa, las mismas filas y los mismos diseños en tu propio equipo.

  1. Abre Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr desde las demos de sgcUI. El README.txt de esa carpeta tiene los detalles.
  2. Compílalo como compilación release para Win64 o Win32, con la optimización activada y las comprobaciones de rango y de desbordamiento desactivadas. Los modos de cálculo en paralelo necesitan la edición Registrada o de prueba.
  3. Ejecútalo desde una consola. Por defecto usa 1,000,000 y 10,000,000 de filas y los números de hilos 1, 2, 4, 8 y todas las CPU.
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
OpciónSignificado
--rowsNúmeros de filas que probar, con los sufijos k y m.
--threadsValores de MaxThreads para los modos paralelos. 0 o all es un hilo por CPU. La pasada única siempre se ejecuta.
--outCarpeta de salida, por defecto una carpeta benchmark junto al exe.
--quick1 ejecución medida tras el calentamiento en lugar de la mediana de 5.

Cada ejecución escribe delphi-<platform>.md, .json y .csv con el equipo, la configuración y cada tiempo, y comprueba los presupuestos de QA con 1,000,000 de filas. BenchmarkMain.pas contiene toda la lógica, así que puedes sustituir las filas generadas por tus propios datos y conservar la misma medición y los mismos informes. Si tus cifras difieren mucho de estas, cuéntanoslo.

Advertencias

Lee estas cifras con cuidado

  • Un solo equipo. Los tiempos de reloj cambian con la CPU (número de núcleos, planificación híbrida, turbo), la velocidad de la memoria y la otra carga del equipo.
  • La forma de los datos importa: más miembros, más valores distintos o más medidas cuestan más tiempo y memoria que los diseños medidos aquí.
  • Las cifras de Win32 proceden de una ejecución rápida con 1 ejecución medida. Las de Win64 son medianas de 5.
  • Esta página no compara sgcPivotGrid con otros componentes de tabla dinámica. Solo publica cifras de sgcPivotGrid, con un método que cualquiera puede repetir.

Los presupuestos de QA también están documentados en el tema de ayuda Architecture.

La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Crea con sgcPivotGrid

Descarga la prueba de sgcUI y añade sgcPivotGrid a tu aplicación Delphi, C++ Builder o .NET.

Prueba y licencias Matriz de funciones