sgcPivotGrid Benchmarks

Temps mesurés du moteur de sgcPivotGrid, TsgcPivotEngine, sur 1 000 000 et 10 000 000 de lignes : chargement des données, recalcul de trois dispositions de pivot en passage unique et avec le calcul parallèle, et mémoire que le moteur ajoute aux données. Chaque chiffre vient d'un programme de benchmark des démos sgcUI, tu peux donc refaire le même test sur ton propre matériel.

13,9 ms
Recalcul de 1 000 000 de lignes, Sum, passage unique
121,1 ms
Recalcul de 10 000 000 de lignes, Sum, passage unique
46,9 ms
10 000 000 de lignes, Sum, calcul parallèle avec 4 threads
1 384,0 ms
Chargement de 10 000 000 de lignes avec AppendRow

Win64, Delphi 13, médiane de 5 exécutions après 1 exécution de chauffe, sur la machine de test décrite plus bas. Va directement aux résultats Win64, aux résultats Win32, aux budgets QA ou à la façon de lancer le test toi-même.

Méthode

Ce qui est mesuré

Les lignes sont générées à partir d'une graine fixe, donc chaque machine calcule le même pivot. Chaque mode vérifie que le total général de P1 est égal à la somme de la colonne de valeurs.

ScénarioCe que fait le programme
ChargementAppendRow de 1 000 000 ou 10 000 000 de lignes avec 3 valeurs texte, 1 nombre et 1 date chacune. Le texte est codé en index de membres à mesure qu'il arrive. Une seconde étape remplit une colonne de nombres avec 100 000 valeurs distinctes via Store.SetFloat.
P1 Sum2 champs de ligne (50 régions par 20 produits, 1 051 éléments de ligne avec les sous-totaux et le total général) et 1 champ de colonne (12 mois), Sum d'une valeur. Le pivot de base.
P3 CountDistinctLa disposition P1 qui compte les valeurs distinctes de la colonne à 100 000 valeurs distinctes, l'agrégat standard le plus coûteux.
P4 StdDev, Average, MaxTrois mesures à la fois sur la disposition P1.
Passage uniqueLe moteur par défaut, ParallelCalculation désactivé.
1 à 14 threadsParallelCalculation := True avec MaxThreads défini et ParallelThreshold := 1, de sorte que 1 000 000 de lignes s'exécutent aussi en parallèle. « Tous les CPU » correspond à MaxThreads := 0, un thread par CPU logique, soit 14 sur la machine de test.
Mémoire du moteurLa mémoire que le moteur alloue en plus des données chargées pour P1 (critère QA M1). La mémoire du store correspond aux données chargées elles-mêmes.
Matériel

Machine de test

Un poste de développement avec sa charge de bureau habituelle, pas une machine de laboratoire isolée. Mesuré le 4 novembre 2026.

ÉlémentValeur
CPUIntel Core Ultra 5 245T, un processeur de bureau de 35 W
Cœurs6 cœurs performants et 8 cœurs économes, 14 CPU logiques
Mémoire31,5 Go
Système d'exploitationWindows 11 Pro 26H2 (build 26300)
CompilateurDelphi 13 Florence, build release : optimisation activée, vérifications de plage et de débordement désactivées
PlateformesWin64 (médiane de 5 exécutions après 1 exécution de chauffe) et Win32 (exécution rapide : 1 exécution chronométrée après 1 exécution de chauffe)
sgcPivotGrid2026.11.0 Enregistrée

Le processeur mélange des cœurs rapides et des cœurs économes, et Windows décide où s'exécute chaque thread de travail. À partir de 8 threads, une partie du travail tombe sur les cœurs économes : P4 sur 1 000 000 de lignes en Win64 alterne alors entre des exécutions d'environ 13 ms et d'environ 32 ms, et sa médiane saute à 31,2 ms avec 8 threads.

Résultats

Win64

Médiane de 5 exécutions après 1 exécution de chauffe. Temps en millisecondes.

Chargement et mémoire1 000 000 de lignes10 000 000 de lignes
AppendRow, colonnes 3 texte, 1 flottant, 1 date132,9 ms1 384,0 ms
Store.SetFloat, 1 colonne flottante avec 100 000 valeurs distinctes8,6 ms98,3 ms
Mémoire du store (6 colonnes)36,0 Mo576,0 Mo
Mémoire du moteur après P1, tous les modes4,8 Mo39,1 Mo

Recalcul, 1 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique113,9 ms25,6 ms26,3 ms
Parallèle, 1 thread112,2 ms21,6 ms26,3 ms
Parallèle, 2 threads29,6 ms18,2 ms17,8 ms
Parallèle, 4 threads47,1 ms15,9 ms12,9 ms
Parallèle, 8 threads86,8 ms15,3 ms31,2 ms
Parallèle, tous les CPU146,8 ms16,5 ms31,8 ms

Recalcul, 10 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique1121,1 ms300,2 ms216,9 ms
Parallèle, 1 thread1106,4 ms253,0 ms230,6 ms
Parallèle, 2 threads267,1 ms212,7 ms130,3 ms
Parallèle, 4 threads446,9 ms184,6 ms127,5 ms
Parallèle, 8 threads863,6 ms181,1 ms111,9 ms
Parallèle, tous les CPU1473,5 ms186,4 ms105,4 ms
Résultats

Win32

Exécution rapide : 1 exécution chronométrée après 1 exécution de chauffe, donc ces chiffres sont plus bruités que les médianes Win64. Le programme est « large address aware », ce dont le store de 10 000 000 de lignes a besoin.

Chargement et mémoire1 000 000 de lignes10 000 000 de lignes
AppendRow, colonnes 3 texte, 1 flottant, 1 date143,7 ms1 511,9 ms
Store.SetFloat, 1 colonne flottante avec 100 000 valeurs distinctes16,8 ms183,7 ms
Mémoire du store (6 colonnes)36,0 Mo576,0 Mo
Mémoire du moteur après P1, tous les modes4,7 Mo39,1 Mo

Recalcul, 1 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique116,9 ms27,3 ms50,8 ms
Parallèle, 1 thread116,7 ms22,9 ms51,0 ms
Parallèle, 2 threads211,3 ms20,4 ms32,8 ms
Parallèle, 4 threads48,6 ms16,3 ms23,1 ms
Parallèle, 8 threads88,5 ms16,3 ms19,2 ms
Parallèle, tous les CPU148,5 ms15,6 ms19,2 ms

Recalcul, 10 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique1143,6 ms286,8 ms442,6 ms
Parallèle, 1 thread1139,4 ms253,6 ms463,7 ms
Parallèle, 2 threads288,0 ms207,8 ms252,4 ms
Parallèle, 4 threads452,5 ms176,8 ms141,7 ms
Parallèle, 8 threads857,2 ms167,1 ms159,6 ms
Parallèle, tous les CPU1464,4 ms172,0 ms131,9 ms
Résultats

.NET x64

Le portage .NET du programme de benchmark, avec les mêmes lignes, dispositions et modes que le programme Delphi. Il s'exécute sur un autre runtime, donc lis ces chiffres comme un tableau à part. Médiane de 5 exécutions après 1 exécution de chauffe. Temps en millisecondes.

Chargement et mémoire1 000 000 de lignes10 000 000 de lignes
AppendRow, colonnes 3 texte, 1 flottant, 1 date75,6 ms770,4 ms
Store.SetFloat, 1 colonne flottante avec 100 000 valeurs distinctes2,9 ms43,0 ms
Mémoire du store (6 colonnes)36,0 Mo576,0 Mo
Mémoire du moteur après P1, tous les modes4,7 Mo39,1 Mo

Runtime : .NET 8.0.31, processus x64, build release, un programme console net8.0 avec sgcPivotGrid 2026.11.0 Enregistrée, sur la machine de test ci-dessus et le même jour. La mémoire est le tas managé vivant, mesuré avec GC.GetTotalMemory(true) après un ramasse-miettes complet.

Recalcul, 1 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique111,9 ms23,3 ms14,7 ms
Parallèle, 1 thread112,1 ms21,3 ms20,1 ms
Parallèle, 2 threads28,5 ms15,5 ms12,6 ms
Parallèle, 4 threads46,3 ms14,8 ms9,9 ms
Parallèle, 8 threads86,8 ms13,6 ms9,8 ms
Parallèle, tous les CPU146,6 ms13,3 ms9,6 ms

Recalcul, 10 000 000 de lignes

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Passage unique167,6 ms275,1 ms128,0 ms
Parallèle, 1 thread176,4 ms215,0 ms175,9 ms
Parallèle, 2 threads244,2 ms159,6 ms89,9 ms
Parallèle, 4 threads428,8 ms133,7 ms56,2 ms
Parallèle, 8 threads834,0 ms151,7 ms72,6 ms
Parallèle, tous les CPU1428,3 ms154,9 ms66,0 ms

Les tests de performance QA de .NET utilisent les budgets Delphi multipliés par 1,2 (P1 120 ms en x64). Chaque critère à 1 000 000 de lignes était dans son budget lors de cette exécution, et le total général de P1 était égal à la somme des valeurs dans chaque mode.

Lancer le benchmark .NET

  1. Ouvre PivotGrid\Benchmark\Benchmark.csproj dans les démos .NET de sgcUI. Le README.md de ce dossier donne les détails.
  2. Compile et lance-le en Release avec le SDK .NET 8 ou plus récent. Les modes de calcul parallèle demandent l'édition Enregistrée ou d'essai.
  3. Les options sont celles du programme Delphi. Chaque exécution écrit dotnet-<arch>.md, .json et .csv, par exemple 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
Qualité

Budgets QA à 1 000 000 de lignes

Le groupe de performance du QA vérifie ces budgets à chaque build, en Win64 et en Win32, et l'exécution du QA échoue quand l'un d'eux n'est pas respecté. 10 000 000 de lignes n'ont pas de budget : le QA les signale seulement.

CritèreCe qui est mesuréBudget Win64Mesuré Win64Budget Win32Mesuré Win32
P1Recalcul de 1 000 000 de lignes, 2 champs de ligne, 1 champ de colonne, 1 Sum100 ms13,9 ms160 ms16,9 ms
P1PP1 avec ParallelCalculation, un thread par CPU100 ms6,8 ms160 ms8,5 ms
P2AppendRow de 1 000 000 de lignes de 3 valeurs texte, 1 flottant et 1 date, codage compris900 ms132,9 ms1 400 ms143,7 ms
P3La disposition P1 avec CountDistinct sur une colonne de 100 000 valeurs distinctes400 ms25,6 ms600 ms27,3 ms
P4La disposition P1 avec StdDev, Average et Max180 ms26,3 ms280 ms50,8 ms
M1Mémoire du moteur au-dessus du store pour P132 Mo4,8 Mo32 Mo4,7 Mo
M1PM1 avec ParallelCalculation, un thread par CPU32 Mo4,8 Mo32 Mo4,7 Mo

Les budgets sont volontairement larges, pour détecter les régressions sur des machines de build lentes. Sur la machine de test, les valeurs mesurées sont de 5,5 à 22 fois inférieures.

Threads

Calcul parallèle

Ce qu'ajoutent les lignes parallèles des tableaux, et combien de threads utiliser. Enregistrée

ParallelCalculation := True découpe un gros recalcul en blocs fixes de 131 072 lignes, calcule les blocs sur des threads de travail et les fusionne dans l'ordre des blocs. MaxThreads limite les threads de travail (0 signifie un par CPU, 64 au maximum), et ParallelThreshold, 1 000 000 de lignes par défaut, garde les stores plus petits sur le passage unique. Il est désactivé par défaut, car Sum, Average, Product et la famille StdDev peuvent différer du passage unique dans les derniers bits. Il est présent dans les éditions Enregistrée et d'essai.

  • Utilise MaxThreads de 4 à 8. Sur la machine de test, 4 threads ont donné le meilleur P1 aux deux tailles en Win64 : 7,1 ms à 1 000 000 de lignes et 46,9 ms à 10 000 000 de lignes, contre 13,9 ms et 121,1 ms en passage unique.
  • Plus de threads n'est pas toujours plus rapide. 1 000 000 de lignes ne font que 8 blocs, donc le démarrage des threads et la fusion pèsent plus que le travail économisé. À 10 000 000 de lignes, P1 prend 73,5 ms avec 14 threads contre 46,9 ms avec 4, parce que la fusion ordonnée s'exécute en série.
  • Les mesures plus lourdes passent mieux à l'échelle. P4 à 10 000 000 de lignes continue de s'améliorer jusqu'à 14 threads en Win64 : 105,4 ms contre 216,9 ms en passage unique.
  • CountDistinct gagne le moins. Son comptage des valeurs distinctes s'exécute en série, donc P3 est environ 1,6 fois plus rapide au mieux.
Reproduire

Lance le benchmark toi-même

Le même programme, les mêmes lignes et les mêmes dispositions sur ton propre matériel.

  1. Ouvre Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr dans les démos sgcUI. Le README.txt de ce dossier donne les détails.
  2. Compile-le en build release pour Win64 ou Win32, avec l'optimisation activée et les vérifications de plage et de débordement désactivées. Les modes de calcul parallèle demandent l'édition Enregistrée ou d'essai.
  3. Lance-le depuis une console. Les valeurs par défaut sont 1 000 000 et 10 000 000 de lignes, et les nombres de threads 1, 2, 4, 8 et tous les 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
OptionSignification
--rowsNombres de lignes à tester, avec les suffixes k et m.
--threadsValeurs de MaxThreads pour les modes parallèles. 0 ou all signifie un thread par CPU. Le passage unique s'exécute toujours.
--outDossier de sortie, par défaut un dossier benchmark à côté de l'exe.
--quick1 exécution chronométrée après la chauffe au lieu de la médiane de 5.

Chaque exécution écrit delphi-<platform>.md, .json et .csv avec la machine, les réglages et chaque mesure, et vérifie les budgets QA à 1 000 000 de lignes. BenchmarkMain.pas contient toute la logique, tu peux donc remplacer les lignes générées par tes propres données et garder le même chronométrage et les mêmes rapports. Si tes chiffres diffèrent beaucoup de ceux-ci, dis-le-nous.

Réserves

Lis ces chiffres avec prudence

  • Une seule machine. Les temps d'horloge changent avec le CPU (nombre de cœurs, ordonnancement hybride, turbo), la vitesse de la mémoire et l'autre charge de la machine.
  • La forme des données compte : plus de membres, plus de valeurs distinctes ou plus de mesures coûtent plus de temps et de mémoire que les dispositions mesurées ici.
  • Les chiffres Win32 viennent d'une exécution rapide avec 1 exécution chronométrée. Les chiffres Win64 sont des médianes de 5.
  • Cette page ne compare pas sgcPivotGrid à d'autres composants de pivot. Elle publie seulement des chiffres de sgcPivotGrid, avec une méthode que chacun peut répéter.

Les budgets QA sont aussi documentés dans la rubrique d'aide Architecture.

Meilleur rapport qualité-prix : All-AccessTous les produits eSeGeCe, Support Premium inclus, à partir de €1,059/an.
Voir les tarifs All-Access

Crée avec sgcPivotGrid

Télécharge l'essai sgcUI et ajoute sgcPivotGrid à ton application Delphi, C++ Builder ou .NET.

Essai & licences Matrice des fonctionnalités