sgcPivotGrid Benchmarks

Gemessene Zeiten der sgcPivotGrid-Engine, TsgcPivotEngine, bei 1.000.000 und 10.000.000 Zeilen: Laden der Daten, Neuberechnung von drei Pivot-Layouts in einem Durchlauf und mit paralleler Berechnung sowie der Speicher, den die Engine zusätzlich zu den Daten belegt. Jede Zahl stammt aus einem Benchmark-Programm in den sgcUI-Demos, sodass du denselben Test auf deiner eigenen Hardware ausführen kannst.

13,9 ms
1.000.000 Zeilen neu berechnen, Sum, ein Durchlauf
121,1 ms
10.000.000 Zeilen neu berechnen, Sum, ein Durchlauf
46,9 ms
10.000.000 Zeilen, Sum, parallele Berechnung mit 4 Threads
1.384,0 ms
10.000.000 Zeilen mit AppendRow laden

Win64, Delphi 13, Median aus 5 Läufen nach 1 Aufwärmlauf, auf dem unten beschriebenen Testrechner. Springe zu den Win64-Ergebnissen, den Win32-Ergebnissen, den QA-Budgets oder zu so führst du den Test selbst aus.

Methode

Was gemessen wird

Die Zeilen werden aus einem festen Startwert erzeugt, sodass jeder Rechner dasselbe Pivot berechnet. In jedem Modus wird geprüft, dass die Gesamtsumme von P1 der Summe der Wertespalte entspricht.

SzenarioWas das Programm macht
LadenAppendRow mit 1.000.000 oder 10.000.000 Zeilen, je 3 Textwerte, 1 Zahl und 1 Datum. Der Text wird beim Eintreffen in Member-Indizes kodiert. Ein zweiter Schritt füllt über Store.SetFloat eine Zahlenspalte mit 100.000 unterschiedlichen Werten.
P1 Sum2 Zeilenfelder (50 Regionen mal 20 Produkte, 1.051 Zeilenelemente mit den Zwischensummen und der Gesamtsumme) und 1 Spaltenfeld (12 Monate), Sum eines Wertes. Das einfache Pivot.
P3 CountDistinctDas Layout P1, das die unterschiedlichen Werte der Spalte mit 100.000 unterschiedlichen Werten zählt, die teuerste Standardaggregation.
P4 StdDev, Average, MaxDrei Kennzahlen gleichzeitig im Layout P1.
Ein DurchlaufDie Standard-Engine, ParallelCalculation aus.
1 bis 14 ThreadsParallelCalculation := True mit gesetztem MaxThreads und ParallelThreshold := 1, sodass auch 1.000.000 Zeilen parallel laufen. "Alle CPUs" ist MaxThreads := 0, ein Thread pro logischer CPU, auf dem Testrechner 14.
Engine-SpeicherDer Speicher, den die Engine für P1 zusätzlich zu den geladenen Daten belegt (QA-Gate M1). Der Store-Speicher sind die geladenen Daten selbst.
Hardware

Testrechner

Eine Entwickler-Workstation mit ihrer normalen Desktop-Last, kein isolierter Laborrechner. Gemessen am 4. November 2026.

EintragWert
CPUIntel Core Ultra 5 245T, ein Desktop-Prozessor mit 35 W
Kerne6 Performance-Kerne und 8 Effizienz-Kerne, 14 logische CPUs
Arbeitsspeicher31,5 GB
BetriebssystemWindows 11 Pro 26H2 (Build 26300)
CompilerDelphi 13 Florence, Release-Build: Optimierung ein, Bereichs- und Überlaufprüfung aus
PlattformenWin64 (Median aus 5 Läufen nach 1 Aufwärmlauf) und Win32 (Schnelllauf: 1 gemessener Lauf nach 1 Aufwärmlauf)
sgcPivotGrid2026.11.0 Registered

Der Prozessor mischt schnelle und effiziente Kerne, und Windows entscheidet, wo jeder Worker-Thread läuft. Ab 8 Threads landet ein Teil der Arbeit auf den Effizienz-Kernen: P4 bei 1.000.000 Zeilen unter Win64 wechselt dann zwischen Läufen von etwa 13 ms und etwa 32 ms, sodass sein Median bei 8 Threads auf 31,2 ms springt.

Ergebnisse

Win64

Median aus 5 Läufen nach 1 Aufwärmlauf. Zeiten in Millisekunden.

Laden und Speicher1.000.000 Zeilen10.000.000 Zeilen
AppendRow, 3 Text-, 1 Gleitkomma-, 1 Datumsspalte132,9 ms1.384,0 ms
Store.SetFloat, 1 Gleitkommaspalte mit 100.000 unterschiedlichen Werten8,6 ms98,3 ms
Store-Speicher (6 Spalten)36,0 MB576,0 MB
Engine-Speicher nach P1, in jedem Modus4,8 MB39,1 MB

Neuberechnung, 1.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf113,9 ms25,6 ms26,3 ms
Parallel, 1 Thread112,2 ms21,6 ms26,3 ms
Parallel, 2 Threads29,6 ms18,2 ms17,8 ms
Parallel, 4 Threads47,1 ms15,9 ms12,9 ms
Parallel, 8 Threads86,8 ms15,3 ms31,2 ms
Parallel, alle CPUs146,8 ms16,5 ms31,8 ms

Neuberechnung, 10.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf1121,1 ms300,2 ms216,9 ms
Parallel, 1 Thread1106,4 ms253,0 ms230,6 ms
Parallel, 2 Threads267,1 ms212,7 ms130,3 ms
Parallel, 4 Threads446,9 ms184,6 ms127,5 ms
Parallel, 8 Threads863,6 ms181,1 ms111,9 ms
Parallel, alle CPUs1473,5 ms186,4 ms105,4 ms
Ergebnisse

Win32

Schnelllauf: 1 gemessener Lauf nach 1 Aufwärmlauf, daher sind diese Zahlen ungenauer als die Win64-Mediane. Das Programm ist Large-Address-Aware, was der Store mit 10.000.000 Zeilen braucht.

Laden und Speicher1.000.000 Zeilen10.000.000 Zeilen
AppendRow, 3 Text-, 1 Gleitkomma-, 1 Datumsspalte143,7 ms1.511,9 ms
Store.SetFloat, 1 Gleitkommaspalte mit 100.000 unterschiedlichen Werten16,8 ms183,7 ms
Store-Speicher (6 Spalten)36,0 MB576,0 MB
Engine-Speicher nach P1, in jedem Modus4,7 MB39,1 MB

Neuberechnung, 1.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf116,9 ms27,3 ms50,8 ms
Parallel, 1 Thread116,7 ms22,9 ms51,0 ms
Parallel, 2 Threads211,3 ms20,4 ms32,8 ms
Parallel, 4 Threads48,6 ms16,3 ms23,1 ms
Parallel, 8 Threads88,5 ms16,3 ms19,2 ms
Parallel, alle CPUs148,5 ms15,6 ms19,2 ms

Neuberechnung, 10.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf1143,6 ms286,8 ms442,6 ms
Parallel, 1 Thread1139,4 ms253,6 ms463,7 ms
Parallel, 2 Threads288,0 ms207,8 ms252,4 ms
Parallel, 4 Threads452,5 ms176,8 ms141,7 ms
Parallel, 8 Threads857,2 ms167,1 ms159,6 ms
Parallel, alle CPUs1464,4 ms172,0 ms131,9 ms
Ergebnisse

.NET x64

Die .NET-Portierung des Benchmark-Programms, mit denselben Zeilen, Layouts und Modi wie das Delphi-Programm. Sie läuft auf einer anderen Laufzeit, lies diese Zahlen also als eigene Tabelle. Median aus 5 Läufen nach 1 Aufwärmlauf. Zeiten in Millisekunden.

Laden und Speicher1.000.000 Zeilen10.000.000 Zeilen
AppendRow, 3 Text-, 1 Gleitkomma-, 1 Datumsspalte75,6 ms770,4 ms
Store.SetFloat, 1 Gleitkommaspalte mit 100.000 unterschiedlichen Werten2,9 ms43,0 ms
Store-Speicher (6 Spalten)36,0 MB576,0 MB
Engine-Speicher nach P1, in jedem Modus4,7 MB39,1 MB

Laufzeit: .NET 8.0.31, x64-Prozess, Release-Build, ein net8.0-Konsolenprogramm mit sgcPivotGrid 2026.11.0 Registered, auf dem Testrechner oben und am selben Tag. Der Speicher ist der lebende verwaltete Heap, gemessen mit GC.GetTotalMemory(true) nach einer vollständigen Garbage Collection.

Neuberechnung, 1.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf111,9 ms23,3 ms14,7 ms
Parallel, 1 Thread112,1 ms21,3 ms20,1 ms
Parallel, 2 Threads28,5 ms15,5 ms12,6 ms
Parallel, 4 Threads46,3 ms14,8 ms9,9 ms
Parallel, 8 Threads86,8 ms13,6 ms9,8 ms
Parallel, alle CPUs146,6 ms13,3 ms9,6 ms

Neuberechnung, 10.000.000 Zeilen

ModusThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Ein Durchlauf167,6 ms275,1 ms128,0 ms
Parallel, 1 Thread176,4 ms215,0 ms175,9 ms
Parallel, 2 Threads244,2 ms159,6 ms89,9 ms
Parallel, 4 Threads428,8 ms133,7 ms56,2 ms
Parallel, 8 Threads834,0 ms151,7 ms72,6 ms
Parallel, alle CPUs1428,3 ms154,9 ms66,0 ms

Die .NET-QA-Performancetests verwenden die Delphi-Budgets mal 1,2 (P1 120 ms unter x64). Jedes Gate bei 1.000.000 Zeilen lag in diesem Lauf innerhalb seines Budgets, und die Gesamtsumme von P1 entsprach in jedem Modus der Summe der Werte.

Den .NET-Benchmark ausführen

  1. Öffne PivotGrid\Benchmark\Benchmark.csproj aus den sgcUI-.NET-Demos. Die README.md in diesem Ordner enthält die Details.
  2. Baue und starte es als Release mit dem .NET-8-SDK oder neuer. Die Modi mit paralleler Berechnung brauchen die Edition Registered oder Trial.
  3. Die Schalter sind die Schalter des Delphi-Programms. Jeder Lauf schreibt dotnet-<arch>.md, .json und .csv, zum Beispiel 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ät

QA-Budgets bei 1.000.000 Zeilen

Die QA-Performancegruppe prüft diese Budgets bei jedem Build, unter Win64 und unter Win32, und der QA-Lauf schlägt fehl, wenn eines überschritten wird. Für 10.000.000 Zeilen gibt es kein Budget: Die QA meldet sie nur.

GateWas gemessen wirdWin64-BudgetWin64 gemessenWin32-BudgetWin32 gemessen
P11.000.000 Zeilen neu berechnen, 2 Zeilenfelder, 1 Spaltenfeld, 1 Sum100 ms13,9 ms160 ms16,9 ms
P1PP1 mit ParallelCalculation, ein Thread pro CPU100 ms6,8 ms160 ms8,5 ms
P2AppendRow von 1.000.000 Zeilen mit 3 Text-, 1 Gleitkomma- und 1 Datumswert, Kodierung eingeschlossen900 ms132,9 ms1.400 ms143,7 ms
P3Das Layout P1 mit CountDistinct auf einer Spalte mit 100.000 unterschiedlichen Werten400 ms25,6 ms600 ms27,3 ms
P4Das Layout P1 mit StdDev, Average und Max180 ms26,3 ms280 ms50,8 ms
M1Engine-Speicher über dem Store für P132 MB4,8 MB32 MB4,7 MB
M1PM1 mit ParallelCalculation, ein Thread pro CPU32 MB4,8 MB32 MB4,7 MB

Die Budgets sind bewusst großzügig, damit sie Regressionen auf langsamen Build-Rechnern erkennen. Auf dem Testrechner liegen die gemessenen Werte zwischen 5,5 und 22 Mal darunter.

Threads

Parallele Berechnung

Was die parallelen Zeilen der Tabellen zeigen und wie viele Threads du verwenden solltest. Nur Registered

ParallelCalculation := True teilt eine große Neuberechnung in feste Blöcke von 131.072 Zeilen, berechnet die Blöcke in Worker-Threads und führt sie in Blockreihenfolge zusammen. MaxThreads begrenzt die Worker (0 ist einer pro CPU, höchstens 64), und ParallelThreshold, standardmäßig 1.000.000 Zeilen, lässt kleinere Stores im einfachen Durchlauf. Es ist standardmäßig aus, weil Sum, Average, Product und die StdDev-Familie in den letzten Bits vom einfachen Durchlauf abweichen können. Es ist in den Editionen Registered und Trial enthalten.

  • Verwende MaxThreads 4 bis 8. Auf dem Testrechner lieferten 4 Threads unter Win64 bei beiden Größen das beste P1: 7,1 ms bei 1.000.000 Zeilen und 46,9 ms bei 10.000.000 Zeilen, gegenüber 13,9 ms und 121,1 ms im einfachen Durchlauf.
  • Mehr Threads sind nicht immer schneller. 1.000.000 Zeilen ergeben nur 8 Blöcke, daher wiegen Thread-Start und Zusammenführung schwerer als die eingesparte Arbeit. Bei 10.000.000 Zeilen braucht P1 mit 14 Threads 73,5 ms gegenüber 46,9 ms mit 4, weil die geordnete Zusammenführung seriell läuft.
  • Schwerere Kennzahlen skalieren weiter. P4 bei 10.000.000 Zeilen wird unter Win64 bis 14 Threads immer besser: 105,4 ms gegenüber 216,9 ms im einfachen Durchlauf.
  • CountDistinct gewinnt am wenigsten. Das Zählen der unterschiedlichen Werte läuft seriell, daher ist P3 bestenfalls etwa 1,6 Mal schneller.
Nachmessen

Den Benchmark selbst ausführen

Dasselbe Programm, dieselben Zeilen und dieselben Layouts auf deiner eigenen Hardware.

  1. Öffne Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr aus den sgcUI-Demos. Die README.txt in diesem Ordner enthält die Details.
  2. Baue es als Release-Build für Win64 oder Win32, mit Optimierung ein und Bereichs- und Überlaufprüfung aus. Die Modi mit paralleler Berechnung brauchen die Edition Registered oder Trial.
  3. Starte es in einer Konsole. Die Standardwerte sind 1.000.000 und 10.000.000 Zeilen und die Thread-Anzahlen 1, 2, 4, 8 und alle CPUs.
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
SchalterBedeutung
--rowsZu testende Zeilenanzahlen, mit den Suffixen k und m.
--threadsMaxThreads-Werte für die parallelen Modi. 0 oder all ist ein Thread pro CPU. Der einfache Durchlauf läuft immer.
--outAusgabeordner, standardmäßig ein Ordner benchmark neben der exe.
--quick1 gemessener Lauf nach dem Aufwärmen statt des Medians aus 5.

Jeder Lauf schreibt delphi-<platform>.md, .json und .csv mit dem Rechner, den Einstellungen und allen Zeiten und prüft die QA-Budgets bei 1.000.000 Zeilen. BenchmarkMain.pas enthält die gesamte Logik, sodass du die erzeugten Zeilen durch deine eigenen Daten ersetzen und dieselbe Zeitmessung und dieselben Berichte behalten kannst. Wenn deine Zahlen stark von diesen abweichen, sag uns Bescheid.

Hinweise

Diese Zahlen mit Vorsicht lesen

  • Ein Rechner. Die Wanduhrzeiten ändern sich mit der CPU (Kernanzahl, Hybrid-Scheduling, Turbo), der Speichergeschwindigkeit und der übrigen Last auf dem Rechner.
  • Die Form der Daten ist wichtig: Mehr Member, mehr unterschiedliche Werte oder mehr Kennzahlen kosten mehr Zeit und Speicher als die hier gemessenen Layouts.
  • Die Win32-Zahlen stammen aus einem Schnelllauf mit 1 gemessenen Lauf. Die Win64-Zahlen sind Mediane aus 5.
  • Diese Seite vergleicht sgcPivotGrid nicht mit anderen Pivot-Komponenten. Sie veröffentlicht nur sgcPivotGrid-Zahlen, mit einer Methode, die jeder wiederholen kann.

Die QA-Budgets sind auch im Hilfethema Architektur dokumentiert.

Bestes Preis-Leistungs-Verhältnis: All-AccessAlle eSeGeCe-Produkte, inklusive Premium-Support, ab €1,059 pro Jahr.
All-Access-Preise ansehen

Baue mit sgcPivotGrid

Lade die sgcUI-Testversion herunter und füge sgcPivotGrid zu deiner Delphi-, C++-Builder- oder .NET-Anwendung hinzu.

Testversion & Lizenzierung Feature-Matrix