sgcPivotGrid Testy wydajności

Zmierzone czasy silnika sgcPivotGrid, TsgcPivotEngine, na 1 000 000 i 10 000 000 wierszy: ładowanie danych, przeliczanie trzech układów tabeli przestawnej w jednym przebiegu i z obliczaniem równoległym oraz pamięć, którą silnik dodaje do danych. Każda liczba pochodzi z programu testowego w demach sgcUI, więc ten sam test możesz uruchomić na własnym sprzęcie.

13,9 ms
Przeliczenie 1 000 000 wierszy, Sum, jeden przebieg
121,1 ms
Przeliczenie 10 000 000 wierszy, Sum, jeden przebieg
46,9 ms
10 000 000 wierszy, Sum, obliczanie równoległe na 4 wątkach
1 384,0 ms
Załadowanie 10 000 000 wierszy przez AppendRow

Win64, Delphi 13, mediana z 5 uruchomień po 1 uruchomieniu rozgrzewkowym, na maszynie testowej opisanej poniżej. Przejdź do wyników Win64, wyników Win32, budżetów QA lub instrukcji, jak uruchomić test samodzielnie.

Metoda

Co jest mierzone

Wiersze są generowane ze stałego ziarna, więc każda maszyna liczy tę samą tabelę przestawną. Każdy tryb sprawdza, czy suma końcowa P1 jest równa sumie kolumny wartości.

ScenariuszCo robi program
ŁadowanieAppendRow dla 1 000 000 lub 10 000 000 wierszy, każdy z 3 wartościami tekstowymi, 1 liczbą i 1 datą. Tekst jest kodowany na indeksy elementów w miarę napływu. Drugi krok wypełnia kolumnę liczbową 100 000 różnych wartości przez Store.SetFloat.
P1 Sum2 pola wierszy (50 regionów po 20 produktów, 1 051 elementów wierszy z sumami częściowymi i sumą końcową) i 1 pole kolumny (12 miesięcy), Sum jednej wartości. Podstawowa tabela przestawna.
P3 CountDistinctUkład P1 zliczający różne wartości kolumny ze 100 000 różnych wartości, najkosztowniejsza standardowa agregacja.
P4 StdDev, Average, MaxTrzy miary naraz w układzie P1.
Jeden przebiegDomyślny silnik, ParallelCalculation wyłączone.
Od 1 do 14 wątkówParallelCalculation := True z ustawionym MaxThreads i ParallelThreshold := 1, więc także 1 000 000 wierszy jest liczone równolegle. „Wszystkie procesory” to MaxThreads := 0, jeden wątek na procesor logiczny, na maszynie testowej 14.
Pamięć silnikaPamięć, którą silnik przydziela ponad załadowane dane dla P1 (bramka QA M1). Pamięć magazynu to same załadowane dane.
Sprzęt

Maszyna testowa

Stacja robocza programisty z normalnym obciążeniem pulpitu, a nie wyizolowana maszyna laboratoryjna. Pomiar wykonano 4 listopada 2026.

ElementWartość
ProcesorIntel Core Ultra 5 245T, procesor desktopowy 35 W
Rdzenie6 rdzeni wydajnych i 8 rdzeni energooszczędnych, 14 procesorów logicznych
Pamięć31,5 GB
System operacyjnyWindows 11 Pro 26H2 (build 26300)
KompilatorDelphi 13 Florence, kompilacja release: optymalizacja włączona, kontrola zakresu i przepełnienia wyłączona
PlatformyWin64 (mediana z 5 uruchomień po 1 uruchomieniu rozgrzewkowym) i Win32 (szybki przebieg: 1 mierzone uruchomienie po 1 uruchomieniu rozgrzewkowym)
sgcPivotGrid2026.11.0 Zarejestrowana

Procesor łączy rdzenie szybkie i energooszczędne, a Windows decyduje, gdzie działa każdy wątek roboczy. Przy 8 wątkach lub więcej część pracy trafia na rdzenie energooszczędne: P4 dla 1 000 000 wierszy na Win64 przeskakuje wtedy między przebiegami po około 13 ms i około 32 ms, więc jego mediana skacze do 31,2 ms przy 8 wątkach.

Wyniki

Win64

Mediana z 5 uruchomień po 1 uruchomieniu rozgrzewkowym. Czasy w milisekundach.

Ładowanie i pamięć1 000 000 wierszy10 000 000 wierszy
AppendRow, kolumny: 3 tekstowe, 1 zmiennoprzecinkowa, 1 data132,9 ms1 384,0 ms
Store.SetFloat, 1 kolumna zmiennoprzecinkowa ze 100 000 różnych wartości8,6 ms98,3 ms
Pamięć magazynu (6 kolumn)36,0 MB576,0 MB
Pamięć silnika po P1, każdy tryb4,8 MB39,1 MB

Przeliczanie, 1 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg113,9 ms25,6 ms26,3 ms
Równolegle, 1 wątek112,2 ms21,6 ms26,3 ms
Równolegle, 2 wątki29,6 ms18,2 ms17,8 ms
Równolegle, 4 wątki47,1 ms15,9 ms12,9 ms
Równolegle, 8 wątków86,8 ms15,3 ms31,2 ms
Równolegle, wszystkie procesory146,8 ms16,5 ms31,8 ms

Przeliczanie, 10 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg1121,1 ms300,2 ms216,9 ms
Równolegle, 1 wątek1106,4 ms253,0 ms230,6 ms
Równolegle, 2 wątki267,1 ms212,7 ms130,3 ms
Równolegle, 4 wątki446,9 ms184,6 ms127,5 ms
Równolegle, 8 wątków863,6 ms181,1 ms111,9 ms
Równolegle, wszystkie procesory1473,5 ms186,4 ms105,4 ms
Wyniki

Win32

Szybki przebieg: 1 mierzone uruchomienie po 1 uruchomieniu rozgrzewkowym, więc te liczby są bardziej zaszumione niż mediany Win64. Program jest large address aware, czego wymaga magazyn 10 000 000 wierszy.

Ładowanie i pamięć1 000 000 wierszy10 000 000 wierszy
AppendRow, kolumny: 3 tekstowe, 1 zmiennoprzecinkowa, 1 data143,7 ms1 511,9 ms
Store.SetFloat, 1 kolumna zmiennoprzecinkowa ze 100 000 różnych wartości16,8 ms183,7 ms
Pamięć magazynu (6 kolumn)36,0 MB576,0 MB
Pamięć silnika po P1, każdy tryb4,7 MB39,1 MB

Przeliczanie, 1 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg116,9 ms27,3 ms50,8 ms
Równolegle, 1 wątek116,7 ms22,9 ms51,0 ms
Równolegle, 2 wątki211,3 ms20,4 ms32,8 ms
Równolegle, 4 wątki48,6 ms16,3 ms23,1 ms
Równolegle, 8 wątków88,5 ms16,3 ms19,2 ms
Równolegle, wszystkie procesory148,5 ms15,6 ms19,2 ms

Przeliczanie, 10 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg1143,6 ms286,8 ms442,6 ms
Równolegle, 1 wątek1139,4 ms253,6 ms463,7 ms
Równolegle, 2 wątki288,0 ms207,8 ms252,4 ms
Równolegle, 4 wątki452,5 ms176,8 ms141,7 ms
Równolegle, 8 wątków857,2 ms167,1 ms159,6 ms
Równolegle, wszystkie procesory1464,4 ms172,0 ms131,9 ms
Wyniki

.NET x64

Port programu testowego na .NET, z tymi samymi wierszami, układami i trybami co program Delphi. Działa na innym środowisku uruchomieniowym, więc traktuj te liczby jako osobną tabelę. Mediana z 5 uruchomień po 1 uruchomieniu rozgrzewkowym. Czasy w milisekundach.

Ładowanie i pamięć1 000 000 wierszy10 000 000 wierszy
AppendRow, kolumny: 3 tekstowe, 1 zmiennoprzecinkowa, 1 data75,6 ms770,4 ms
Store.SetFloat, 1 kolumna zmiennoprzecinkowa ze 100 000 różnych wartości2,9 ms43,0 ms
Pamięć magazynu (6 kolumn)36,0 MB576,0 MB
Pamięć silnika po P1, każdy tryb4,7 MB39,1 MB

Środowisko: .NET 8.0.31, proces x64, kompilacja release, program konsolowy net8.0 z sgcPivotGrid 2026.11.0 Zarejestrowana, na maszynie testowej opisanej wyżej i tego samego dnia. Pamięć to żywy zarządzany stos, zmierzony przez GC.GetTotalMemory(true) po pełnym odśmiecaniu.

Przeliczanie, 1 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg111,9 ms23,3 ms14,7 ms
Równolegle, 1 wątek112,1 ms21,3 ms20,1 ms
Równolegle, 2 wątki28,5 ms15,5 ms12,6 ms
Równolegle, 4 wątki46,3 ms14,8 ms9,9 ms
Równolegle, 8 wątków86,8 ms13,6 ms9,8 ms
Równolegle, wszystkie procesory146,6 ms13,3 ms9,6 ms

Przeliczanie, 10 000 000 wierszy

TrybWątkiP1 SumP3 CountDistinctP4 StdDev, Average, Max
Jeden przebieg167,6 ms275,1 ms128,0 ms
Równolegle, 1 wątek176,4 ms215,0 ms175,9 ms
Równolegle, 2 wątki244,2 ms159,6 ms89,9 ms
Równolegle, 4 wątki428,8 ms133,7 ms56,2 ms
Równolegle, 8 wątków834,0 ms151,7 ms72,6 ms
Równolegle, wszystkie procesory1428,3 ms154,9 ms66,0 ms

Testy wydajności QA dla .NET używają budżetów Delphi razy 1,2 (P1 120 ms na x64). Każda bramka dla 1 000 000 wierszy mieściła się w budżecie w tym przebiegu, a suma końcowa P1 była równa sumie wartości w każdym trybie.

Uruchom test .NET

  1. Otwórz PivotGrid\Benchmark\Benchmark.csproj z dem sgcUI dla .NET. Szczegóły są w pliku README.md w tym folderze.
  2. Zbuduj i uruchom w trybie Release z .NET 8 SDK lub nowszym. Tryby obliczania równoległego wymagają edycji zarejestrowanej lub wersji próbnej.
  3. Przełączniki są takie same jak w programie Delphi. Każde uruchomienie zapisuje dotnet-<arch>.md, .json i .csv, na przykład 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
Jakość

Budżety QA dla 1 000 000 wierszy

Grupa testów wydajności QA sprawdza te budżety przy każdej kompilacji, na Win64 i na Win32, a uruchomienie QA kończy się błędem, gdy któryś zostanie przekroczony. Dla 10 000 000 wierszy nie ma budżetu: QA tylko je raportuje.

BramkaCo jest mierzoneBudżet Win64Pomiar Win64Budżet Win32Pomiar Win32
P1Przeliczenie 1 000 000 wierszy, 2 pola wierszy, 1 pole kolumny, 1 Sum100 ms13,9 ms160 ms16,9 ms
P1PP1 z ParallelCalculation, jeden wątek na procesor100 ms6,8 ms160 ms8,5 ms
P2AppendRow dla 1 000 000 wierszy z 3 wartościami tekstowymi, 1 zmiennoprzecinkową i 1 datą, z kodowaniem900 ms132,9 ms1 400 ms143,7 ms
P3Układ P1 z CountDistinct na kolumnie ze 100 000 różnych wartości400 ms25,6 ms600 ms27,3 ms
P4Układ P1 z StdDev, Average i Max180 ms26,3 ms280 ms50,8 ms
M1Pamięć silnika ponad magazyn dla P132 MB4,8 MB32 MB4,7 MB
M1PM1 z ParallelCalculation, jeden wątek na procesor32 MB4,8 MB32 MB4,7 MB

Budżety są celowo luźne, żeby wychwytywały regresje na wolnych maszynach budujących. Na maszynie testowej zmierzone wartości są od 5,5 do 22 razy niższe.

Wątki

Obliczanie równoległe

Co dodają wiersze równoległe w tabelach i ile wątków użyć. Zarejestrowana

ParallelCalculation := True dzieli duże przeliczenie na stałe porcje po 131 072 wiersze, liczy porcje na wątkach roboczych i łączy je w kolejności porcji. MaxThreads ogranicza liczbę wątków roboczych (0 to jeden na procesor, najwyżej 64), a ParallelThreshold, domyślnie 1 000 000 wierszy, zostawia mniejsze magazyny w jednym przebiegu. Opcja jest domyślnie wyłączona, ponieważ Sum, Average, Product i rodzina StdDev mogą różnić się od jednego przebiegu na ostatnich bitach. Jest dostępna w edycji zarejestrowanej i w wersji próbnej.

  • Użyj MaxThreads od 4 do 8. Na maszynie testowej 4 wątki dały najlepszy P1 w obu rozmiarach na Win64: 7,1 ms dla 1 000 000 wierszy i 46,9 ms dla 10 000 000 wierszy, wobec 13,9 ms i 121,1 ms w jednym przebiegu.
  • Więcej wątków nie zawsze znaczy szybciej. 1 000 000 wierszy to tylko 8 porcji, więc koszt startu wątków i łączenia waży więcej niż zaoszczędzona praca. Przy 10 000 000 wierszy P1 trwa 73,5 ms na 14 wątkach wobec 46,9 ms na 4, bo uporządkowane łączenie działa szeregowo.
  • Cięższe miary skalują się dalej. P4 dla 10 000 000 wierszy poprawia się aż do 14 wątków na Win64: 105,4 ms wobec 216,9 ms w jednym przebiegu.
  • CountDistinct zyskuje najmniej. Zliczanie różnych wartości działa szeregowo, więc P3 jest co najwyżej około 1,6 raza szybszy.
Odtworzenie

Uruchom test samodzielnie

Ten sam program, te same wiersze i te same układy na własnym sprzęcie.

  1. Otwórz Demos\PivotGrid\Delphi\Benchmark\sgcPivotGridBenchmark.dpr z dem sgcUI. Szczegóły są w pliku README.txt w tym folderze.
  2. Zbuduj go jako kompilację release dla Win64 lub Win32, z włączoną optymalizacją i wyłączoną kontrolą zakresu i przepełnienia. Tryby obliczania równoległego wymagają edycji zarejestrowanej lub wersji próbnej.
  3. Uruchom go z konsoli. Domyślnie testuje 1 000 000 i 10 000 000 wierszy oraz 1, 2, 4, 8 wątków i wszystkie procesory.
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
PrzełącznikZnaczenie
--rowsLiczby wierszy do przetestowania, z przyrostkami k i m.
--threadsWartości MaxThreads dla trybów równoległych. 0 lub all to jeden wątek na procesor. Jeden przebieg zawsze się wykonuje.
--outFolder wyjściowy, domyślnie folder benchmark obok pliku exe.
--quick1 mierzone uruchomienie po rozgrzewce zamiast mediany z 5.

Każde uruchomienie zapisuje delphi-<platform>.md, .json i .csv z maszyną, ustawieniami i każdym pomiarem oraz sprawdza budżety QA dla 1 000 000 wierszy. BenchmarkMain.pas zawiera całą logikę, więc możesz zastąpić generowane wiersze własnymi danymi i zachować ten sam pomiar czasu i raporty. Jeśli Twoje liczby bardzo się różnią od tych, napisz do nas.

Zastrzeżenia

Czytaj te liczby ostrożnie

  • Jedna maszyna. Czasy zegarowe zależą od procesora (liczba rdzeni, szeregowanie hybrydowe, turbo), szybkości pamięci i innego obciążenia maszyny.
  • Kształt danych ma znaczenie: więcej elementów, więcej różnych wartości lub więcej miar kosztuje więcej czasu i pamięci niż zmierzone tu układy.
  • Liczby Win32 pochodzą z szybkiego przebiegu z 1 mierzonym uruchomieniem. Liczby Win64 to mediany z 5.
  • Ta strona nie porównuje sgcPivotGrid z innymi komponentami tabel przestawnych. Publikuje wyłącznie liczby sgcPivotGrid, z metodą, którą każdy może powtórzyć.

Budżety QA są też opisane w temacie pomocy Architecture.

Najkorzystniejsza oferta: All-AccessWszystkie produkty eSeGeCe, ze wsparciem Premium w cenie, już od €1,059 rocznie.
Zobacz cennik All-Access

Twórz z sgcPivotGrid

Pobierz wersję próbną sgcUI i dodaj sgcPivotGrid do aplikacji w Delphi, C++ Builder lub .NET.

Wersja próbna i licencje Macierz funkcji