sgcPivotGrid Benchmarks

Measured times of the sgcPivotGrid engine, TsgcPivotEngine, on 1,000,000 and 10,000,000 rows: loading the data, recalculating three pivot layouts in a single pass and with parallel calculation, and the memory the engine adds on top of the data. Every number comes from a benchmark program in the sgcUI demos, so you can run the same test on your own hardware.

13.9 ms
Recalculate 1,000,000 rows, Sum, single pass
121.1 ms
Recalculate 10,000,000 rows, Sum, single pass
46.9 ms
10,000,000 rows, Sum, parallel calculation with 4 threads
1,384.0 ms
Load 10,000,000 rows with AppendRow

Win64, Delphi 13, median of 5 runs after 1 warm up run, on the test machine described below. Jump to the Win64 results, the Win32 results, the QA budgets or how to run the test yourself.

Method

What Is Measured

The rows are generated from a fixed seed, so every machine computes the same pivot. Every mode checks that the P1 grand total equals the sum of the value column.

ScenarioWhat the program does
LoadAppendRow of 1,000,000 or 10,000,000 rows with 3 text values, 1 number and 1 date each. The text is encoded into member indexes as it arrives. A second step fills a number column with 100,000 distinct values through Store.SetFloat.
P1 Sum2 row fields (50 regions by 20 products, 1,051 row items with the subtotals and the grand total) and 1 column field (12 months), Sum of one value. The basic pivot.
P3 CountDistinctThe P1 layout counting the distinct values of the column with 100,000 distinct values, the most expensive standard aggregate.
P4 StdDev, Average, MaxThree measures at once on the P1 layout.
Single passThe default engine, ParallelCalculation off.
1 to 14 threadsParallelCalculation := True with MaxThreads set and ParallelThreshold := 1, so 1,000,000 rows also run in parallel. "All CPUs" is MaxThreads := 0, one thread per logical CPU, 14 on the test machine.
Engine memoryThe memory the engine allocates on top of the loaded data for P1 (QA gate M1). Store memory is the loaded data itself.
Hardware

Test Machine

A developer workstation with its normal desktop load, not an isolated lab machine. Measured on 4 November 2026.

ItemValue
CPUIntel Core Ultra 5 245T, a 35 W desktop processor
Cores6 performance cores and 8 efficient cores, 14 logical CPUs
Memory31.5 GB
Operating systemWindows 11 Pro 26H2 (build 26300)
CompilerDelphi 13 Florence, release build: optimization on, range and overflow checks off
PlatformsWin64 (median of 5 runs after 1 warm up run) and Win32 (quick run: 1 timed run after 1 warm up run)
sgcPivotGrid2026.11.0 Registered

The processor mixes fast and efficient cores, and Windows decides where each worker thread runs. With 8 threads or more some work lands on the efficient cores: P4 at 1,000,000 rows on Win64 then alternates between runs of about 13 ms and about 32 ms, so its median jumps to 31.2 ms with 8 threads.

Results

Win64

Median of 5 runs after 1 warm up run. Times in milliseconds.

Load and memory1,000,000 rows10,000,000 rows
AppendRow, 3 text, 1 float, 1 date columns132.9 ms1,384.0 ms
Store.SetFloat, 1 float column with 100,000 distinct values8.6 ms98.3 ms
Store memory (6 columns)36.0 MB576.0 MB
Engine memory after P1, every mode4.8 MB39.1 MB

Recalculation, 1,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass113.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, all CPUs146.8 ms16.5 ms31.8 ms

Recalculation, 10,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass1121.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, all CPUs1473.5 ms186.4 ms105.4 ms
Results

Win32

Quick run: 1 timed run after 1 warm up run, so these numbers are noisier than the Win64 medians. The program is large address aware, which the 10,000,000 row store needs.

Load and memory1,000,000 rows10,000,000 rows
AppendRow, 3 text, 1 float, 1 date columns143.7 ms1,511.9 ms
Store.SetFloat, 1 float column with 100,000 distinct values16.8 ms183.7 ms
Store memory (6 columns)36.0 MB576.0 MB
Engine memory after P1, every mode4.7 MB39.1 MB

Recalculation, 1,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass116.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, all CPUs148.5 ms15.6 ms19.2 ms

Recalculation, 10,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass1143.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, all CPUs1464.4 ms172.0 ms131.9 ms
Results

.NET x64

The .NET port of the benchmark program, with the same rows, layouts and modes as the Delphi program. It runs on another runtime, so read these numbers as their own table. Median of 5 runs after 1 warm up run. Times in milliseconds.

Load and memory1,000,000 rows10,000,000 rows
AppendRow, 3 text, 1 float, 1 date columns75.6 ms770.4 ms
Store.SetFloat, 1 float column with 100,000 distinct values2.9 ms43.0 ms
Store memory (6 columns)36.0 MB576.0 MB
Engine memory after P1, every mode4.7 MB39.1 MB

Runtime: .NET 8.0.31, x64 process, release build, a net8.0 console program with sgcPivotGrid 2026.11.0 Registered, on the test machine above and on the same day. Memory is the live managed heap, measured with GC.GetTotalMemory(true) after a full collection.

Recalculation, 1,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass111.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, all CPUs146.6 ms13.3 ms9.6 ms

Recalculation, 10,000,000 rows

ModeThreadsP1 SumP3 CountDistinctP4 StdDev, Average, Max
Single pass167.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, all CPUs1428.3 ms154.9 ms66.0 ms

The .NET QA performance tests use the Delphi budgets times 1.2 (P1 120 ms on x64). Every gate at 1,000,000 rows was within its budget in this run, and the P1 grand total equalled the sum of the values in every mode.

Run the .NET Benchmark

  1. Open PivotGrid\Benchmark\Benchmark.csproj from the sgcUI .NET demos. The README.md in that folder has the details.
  2. Build and run it in Release with the .NET 8 SDK or newer. The parallel calculation modes need the Registered or Trial edition.
  3. The switches are the switches of the Delphi program. Each run writes dotnet-<arch>.md, .json and .csv, for example 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
Quality

QA Budgets at 1,000,000 Rows

The QA performance group asserts these budgets on every build, on Win64 and on Win32, and the QA run fails when one is missed. 10,000,000 rows have no budget: the QA reports them only.

GateWhat is measuredWin64 budgetWin64 measuredWin32 budgetWin32 measured
P1Recalculate 1,000,000 rows, 2 row fields, 1 column field, 1 Sum100 ms13.9 ms160 ms16.9 ms
P1PP1 with ParallelCalculation, one thread per CPU100 ms6.8 ms160 ms8.5 ms
P2AppendRow of 1,000,000 rows of 3 text, 1 float and 1 date values, encoding included900 ms132.9 ms1,400 ms143.7 ms
P3The P1 layout with CountDistinct on a column with 100,000 distinct values400 ms25.6 ms600 ms27.3 ms
P4The P1 layout with StdDev, Average and Max180 ms26.3 ms280 ms50.8 ms
M1Engine memory above the store for P132 MB4.8 MB32 MB4.7 MB
M1PM1 with ParallelCalculation, one thread per CPU32 MB4.8 MB32 MB4.7 MB

The budgets are deliberately loose, so they catch regressions on slow build machines. On the test machine the measured values sit between 5.5 and 22 times below them.

Threads

Parallel Calculation

What the parallel rows of the tables add, and how many threads to use. Registered

ParallelCalculation := True splits a large recalculation into fixed chunks of 131,072 rows, computes the chunks on worker threads and merges them in chunk order. MaxThreads limits the workers (0 is one per CPU, at most 64), and ParallelThreshold, 1,000,000 rows by default, keeps smaller stores on the single pass. It is off by default, because Sum, Average, Product and the StdDev family can differ from the single pass in the last bits. It is in the Registered and Trial editions.

  • Use MaxThreads 4 to 8. On the test machine 4 threads gave the best P1 at both sizes on Win64: 7.1 ms at 1,000,000 rows and 46.9 ms at 10,000,000 rows, against 13.9 ms and 121.1 ms in a single pass.
  • More threads is not always faster. 1,000,000 rows make only 8 chunks, so thread start and merge costs weigh more than the work saved. At 10,000,000 rows P1 takes 73.5 ms with 14 threads against 46.9 ms with 4, because the ordered merge runs serially.
  • Heavier measures scale further. P4 at 10,000,000 rows keeps improving up to 14 threads on Win64: 105.4 ms against 216.9 ms in a single pass.
  • CountDistinct gains least. Its counting of distinct values runs serially, so P3 is about 1.6 times faster at best.
Reproduce

Run the Benchmark Yourself

The same program, the same rows and the same layouts on your own hardware.

  1. Open Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr from the sgcUI demos. The README.txt in that folder has the details.
  2. Build it as a release build for Win64 or Win32, with optimization on and range and overflow checks off. The parallel calculation modes need the Registered or Trial edition.
  3. Run it from a console. The defaults are 1,000,000 and 10,000,000 rows and the thread counts 1, 2, 4, 8 and all 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
SwitchMeaning
--rowsRow counts to test, with k and m suffixes.
--threadsMaxThreads values for the parallel modes. 0 or all is one thread per CPU. The single pass always runs.
--outOutput folder, by default a benchmark folder next to the exe.
--quick1 timed run after the warm up instead of the median of 5.

Each run writes delphi-<platform>.md, .json and .csv with the machine, the settings and every timing, and checks the QA budgets at 1,000,000 rows. BenchmarkMain.pas holds all the logic, so you can replace the generated rows with your own data and keep the same timing and reports. If your numbers differ a lot from these, tell us.

Caveats

Read These Numbers With Care

  • One machine. Wall clock times change with the CPU (core count, hybrid scheduling, turbo), the memory speed and the other load on the machine.
  • The data shape matters: more members, more distinct values or more measures cost more time and memory than the layouts measured here.
  • The Win32 numbers come from a quick run with 1 timed run. The Win64 numbers are medians of 5.
  • This page does not compare sgcPivotGrid with other pivot components. It publishes sgcPivotGrid numbers only, with a method anyone can repeat.

The QA budgets are also documented in the Architecture help topic.

Best value: All-AccessEvery eSeGeCe product, Premium Support included, from €1,059/year.
See All-Access pricing

Build with sgcPivotGrid

Download the sgcUI trial and add sgcPivotGrid to your Delphi, C++ Builder or .NET application.

Trial & Licensing Feature Matrix