Tempi misurati del motore di sgcPivotGrid, TsgcPivotEngine, su 1.000.000 e 10.000.000 di righe: caricamento dei dati, ricalcolo di tre layout pivot in un solo passaggio e con calcolo parallelo, e memoria che il motore aggiunge ai dati. Ogni numero proviene da un programma di benchmark nelle demo di sgcUI, quindi puoi eseguire lo stesso test sul tuo hardware.
AppendRowWin64, Delphi 13, mediana di 5 esecuzioni dopo 1 esecuzione di riscaldamento, sulla macchina di prova descritta più avanti. Vai ai risultati Win64, ai risultati Win32, ai budget del QA o a come eseguire il test da solo.
Le righe sono generate da un seme fisso, quindi ogni macchina calcola lo stesso pivot. Ogni modalità verifica che il totale generale di P1 sia uguale alla somma della colonna dei valori.
| Scenario | Che cosa fa il programma |
|---|---|
| Caricamento | AppendRow di 1.000.000 o 10.000.000 di righe con 3 valori di testo, 1 numero e 1 data ciascuna. Il testo viene codificato in indici di membro man mano che arriva. Un secondo passaggio riempie una colonna numerica con 100.000 valori distinti tramite Store.SetFloat. |
| P1 Somma | 2 campi riga (50 regioni per 20 prodotti, 1.051 elementi riga con i subtotali e il totale generale) e 1 campo colonna (12 mesi), Somma di un valore. Il pivot di base. |
| P3 CountDistinct | Il layout P1 che conta i valori distinti della colonna con 100.000 valori distinti, l'aggregazione standard più costosa. |
| P4 StdDev, Media, Max | Tre misure contemporaneamente sul layout P1. |
| Un solo passaggio | Il motore predefinito, con ParallelCalculation disattivato. |
| Da 1 a 14 thread | ParallelCalculation := True con MaxThreads impostato e ParallelThreshold := 1, così anche 1.000.000 di righe vengono eseguiti in parallelo. "Tutte le CPU" è MaxThreads := 0, un thread per CPU logica, 14 sulla macchina di prova. |
| Memoria del motore | La memoria che il motore alloca oltre ai dati caricati per P1 (gate QA M1). La memoria dello store sono i dati caricati stessi. |
Una workstation di sviluppo con il suo normale carico desktop, non una macchina da laboratorio isolata. Misurato il 4 novembre 2026.
| Voce | Valore |
|---|---|
| CPU | Intel Core Ultra 5 245T, un processore desktop da 35 W |
| Core | 6 core prestazionali e 8 core efficienti, 14 CPU logiche |
| Memoria | 31,5 GB |
| Sistema operativo | Windows 11 Pro 26H2 (build 26300) |
| Compilatore | Delphi 13 Florence, build di rilascio: ottimizzazione attiva, controlli di intervallo e overflow disattivati |
| Piattaforme | Win64 (mediana di 5 esecuzioni dopo 1 esecuzione di riscaldamento) e Win32 (esecuzione rapida: 1 esecuzione misurata dopo 1 esecuzione di riscaldamento) |
| sgcPivotGrid | 2026.11.0 Registered |
Il processore combina core veloci ed efficienti, e Windows decide dove viene eseguito ogni thread di lavoro. Con 8 thread o più una parte del lavoro finisce sui core efficienti: P4 con 1.000.000 di righe su Win64 alterna allora esecuzioni di circa 13 ms e di circa 32 ms, per cui la sua mediana sale a 31,2 ms con 8 thread.
Mediana di 5 esecuzioni dopo 1 esecuzione di riscaldamento. Tempi in millisecondi.
| Caricamento e memoria | 1.000.000 di righe | 10.000.000 di righe |
|---|---|---|
AppendRow, 3 colonne di testo, 1 float, 1 data | 132,9 ms | 1.384,0 ms |
Store.SetFloat, 1 colonna float con 100.000 valori distinti | 8,6 ms | 98,3 ms |
| Memoria dello store (6 colonne) | 36,0 MB | 576,0 MB |
| Memoria del motore dopo P1, in ogni modalità | 4,8 MB | 39,1 MB |
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 13,9 ms | 25,6 ms | 26,3 ms |
| Parallelo, 1 thread | 1 | 12,2 ms | 21,6 ms | 26,3 ms |
| Parallelo, 2 thread | 2 | 9,6 ms | 18,2 ms | 17,8 ms |
| Parallelo, 4 thread | 4 | 7,1 ms | 15,9 ms | 12,9 ms |
| Parallelo, 8 thread | 8 | 6,8 ms | 15,3 ms | 31,2 ms |
| Parallelo, tutte le CPU | 14 | 6,8 ms | 16,5 ms | 31,8 ms |
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 121,1 ms | 300,2 ms | 216,9 ms |
| Parallelo, 1 thread | 1 | 106,4 ms | 253,0 ms | 230,6 ms |
| Parallelo, 2 thread | 2 | 67,1 ms | 212,7 ms | 130,3 ms |
| Parallelo, 4 thread | 4 | 46,9 ms | 184,6 ms | 127,5 ms |
| Parallelo, 8 thread | 8 | 63,6 ms | 181,1 ms | 111,9 ms |
| Parallelo, tutte le CPU | 14 | 73,5 ms | 186,4 ms | 105,4 ms |
Esecuzione rapida: 1 esecuzione misurata dopo 1 esecuzione di riscaldamento, quindi questi numeri sono più rumorosi delle mediane Win64. Il programma è large address aware, cosa di cui ha bisogno lo store da 10.000.000 di righe.
| Caricamento e memoria | 1.000.000 di righe | 10.000.000 di righe |
|---|---|---|
AppendRow, 3 colonne di testo, 1 float, 1 data | 143,7 ms | 1.511,9 ms |
Store.SetFloat, 1 colonna float con 100.000 valori distinti | 16,8 ms | 183,7 ms |
| Memoria dello store (6 colonne) | 36,0 MB | 576,0 MB |
| Memoria del motore dopo P1, in ogni modalità | 4,7 MB | 39,1 MB |
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 16,9 ms | 27,3 ms | 50,8 ms |
| Parallelo, 1 thread | 1 | 16,7 ms | 22,9 ms | 51,0 ms |
| Parallelo, 2 thread | 2 | 11,3 ms | 20,4 ms | 32,8 ms |
| Parallelo, 4 thread | 4 | 8,6 ms | 16,3 ms | 23,1 ms |
| Parallelo, 8 thread | 8 | 8,5 ms | 16,3 ms | 19,2 ms |
| Parallelo, tutte le CPU | 14 | 8,5 ms | 15,6 ms | 19,2 ms |
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 143,6 ms | 286,8 ms | 442,6 ms |
| Parallelo, 1 thread | 1 | 139,4 ms | 253,6 ms | 463,7 ms |
| Parallelo, 2 thread | 2 | 88,0 ms | 207,8 ms | 252,4 ms |
| Parallelo, 4 thread | 4 | 52,5 ms | 176,8 ms | 141,7 ms |
| Parallelo, 8 thread | 8 | 57,2 ms | 167,1 ms | 159,6 ms |
| Parallelo, tutte le CPU | 14 | 64,4 ms | 172,0 ms | 131,9 ms |
Il port .NET del programma di benchmark, con le stesse righe, gli stessi layout e le stesse modalità del programma Delphi. Gira su un altro runtime, quindi leggi questi numeri come una tabella a parte. Mediana di 5 esecuzioni dopo 1 esecuzione di riscaldamento. Tempi in millisecondi.
| Caricamento e memoria | 1.000.000 di righe | 10.000.000 di righe |
|---|---|---|
AppendRow, 3 colonne di testo, 1 float, 1 data | 75,6 ms | 770,4 ms |
Store.SetFloat, 1 colonna float con 100.000 valori distinti | 2,9 ms | 43,0 ms |
| Memoria dello store (6 colonne) | 36,0 MB | 576,0 MB |
| Memoria del motore dopo P1, in ogni modalità | 4,7 MB | 39,1 MB |
Runtime: .NET 8.0.31, processo x64, build di rilascio, un programma console net8.0 con sgcPivotGrid 2026.11.0 Registered, sulla macchina di prova qui sopra e nello stesso giorno. La memoria è l'heap gestito attivo, misurato con GC.GetTotalMemory(true) dopo una raccolta completa.
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 11,9 ms | 23,3 ms | 14,7 ms |
| Parallelo, 1 thread | 1 | 12,1 ms | 21,3 ms | 20,1 ms |
| Parallelo, 2 thread | 2 | 8,5 ms | 15,5 ms | 12,6 ms |
| Parallelo, 4 thread | 4 | 6,3 ms | 14,8 ms | 9,9 ms |
| Parallelo, 8 thread | 8 | 6,8 ms | 13,6 ms | 9,8 ms |
| Parallelo, tutte le CPU | 14 | 6,6 ms | 13,3 ms | 9,6 ms |
| Modalità | Thread | P1 Somma | P3 CountDistinct | P4 StdDev, Media, Max |
|---|---|---|---|---|
| Un solo passaggio | 1 | 67,6 ms | 275,1 ms | 128,0 ms |
| Parallelo, 1 thread | 1 | 76,4 ms | 215,0 ms | 175,9 ms |
| Parallelo, 2 thread | 2 | 44,2 ms | 159,6 ms | 89,9 ms |
| Parallelo, 4 thread | 4 | 28,8 ms | 133,7 ms | 56,2 ms |
| Parallelo, 8 thread | 8 | 34,0 ms | 151,7 ms | 72,6 ms |
| Parallelo, tutte le CPU | 14 | 28,3 ms | 154,9 ms | 66,0 ms |
I test di prestazioni del QA .NET usano i budget Delphi moltiplicati per 1,2 (P1 120 ms su x64). Ogni gate con 1.000.000 di righe è rimasto entro il proprio budget in questa esecuzione, e il totale generale di P1 era uguale alla somma dei valori in ogni modalità.
PivotGrid\Benchmark\Benchmark.csproj dalle demo .NET di sgcUI. Il README.md in quella cartella contiene i dettagli.dotnet-<arch>.md, .json e .csv, per esempio 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:\benchIl gruppo di prestazioni del QA verifica questi budget a ogni build, su Win64 e su Win32, e l'esecuzione del QA fallisce se uno viene superato. 10.000.000 di righe non hanno budget: il QA le riporta soltanto.
| Gate | Che cosa si misura | Budget Win64 | Misurato Win64 | Budget Win32 | Misurato Win32 |
|---|---|---|---|---|---|
| P1 | Ricalcolo di 1.000.000 di righe, 2 campi riga, 1 campo colonna, 1 Somma | 100 ms | 13,9 ms | 160 ms | 16,9 ms |
| P1P | P1 con ParallelCalculation, un thread per CPU | 100 ms | 6,8 ms | 160 ms | 8,5 ms |
| P2 | AppendRow di 1.000.000 di righe con 3 valori di testo, 1 float e 1 data, codifica inclusa | 900 ms | 132,9 ms | 1.400 ms | 143,7 ms |
| P3 | Il layout P1 con CountDistinct su una colonna con 100.000 valori distinti | 400 ms | 25,6 ms | 600 ms | 27,3 ms |
| P4 | Il layout P1 con StdDev, Media e Max | 180 ms | 26,3 ms | 280 ms | 50,8 ms |
| M1 | Memoria del motore oltre lo store per P1 | 32 MB | 4,8 MB | 32 MB | 4,7 MB |
| M1P | M1 con ParallelCalculation, un thread per CPU | 32 MB | 4,8 MB | 32 MB | 4,7 MB |
I budget sono volutamente larghi, così intercettano le regressioni su macchine di build lente. Sulla macchina di prova i valori misurati sono da 5,5 a 22 volte inferiori.
Che cosa aggiungono le righe parallele delle tabelle e quanti thread usare. Registered
ParallelCalculation := True divide un ricalcolo di grandi dimensioni in blocchi fissi di 131.072 righe, calcola i blocchi su thread di lavoro e li unisce nell'ordine dei blocchi. MaxThreads limita i thread di lavoro (0 è uno per CPU, al massimo 64), e ParallelThreshold, 1.000.000 di righe per impostazione predefinita, mantiene gli store più piccoli sul passaggio singolo. È disattivato per impostazione predefinita, perché Somma, Media, Prodotto e la famiglia StdDev possono differire dal passaggio singolo negli ultimi bit. È presente nelle edizioni Registered e Trial.
MaxThreads da 4 a 8. Sulla macchina di prova 4 thread hanno dato il miglior P1 a entrambe le dimensioni su Win64: 7,1 ms con 1.000.000 di righe e 46,9 ms con 10.000.000 di righe, contro 13,9 ms e 121,1 ms in un solo passaggio.Lo stesso programma, le stesse righe e gli stessi layout sul tuo hardware.
Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr dalle demo di sgcUI. Il README.txt in quella cartella contiene i dettagli.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| Switch | Significato |
|---|---|
--rows | Numeri di righe da provare, con i suffissi k e m. |
--threads | Valori di MaxThreads per le modalità parallele. 0 o all è un thread per CPU. Il passaggio singolo viene sempre eseguito. |
--out | Cartella di output, per impostazione predefinita una cartella benchmark accanto all'exe. |
--quick | 1 esecuzione misurata dopo il riscaldamento invece della mediana di 5. |
Ogni esecuzione scrive delphi-<platform>.md, .json e .csv con la macchina, le impostazioni e ogni tempo, e verifica i budget del QA con 1.000.000 di righe. BenchmarkMain.pas contiene tutta la logica, quindi puoi sostituire le righe generate con i tuoi dati e mantenere gli stessi tempi e rapporti. Se i tuoi numeri differiscono molto da questi, scrivici.
I budget del QA sono documentati anche nell'argomento della guida Architecture.