Ogni numero di questa pagina è stato misurato su un'unica macchina con i gate di prestazioni QA di sgcGrid e due programmi di benchmark inclusi nella suite QA. Nulla è stimato o estrapolato. Esegui gli stessi programmi sul tuo hardware e sul tuo database per ottenere i tuoi numeri.
| Misura | Win32 | Win64 |
|---|---|---|
| Frame 1920 x 1080 di una griglia con 100.000 righe, 12 colonne (gate QA C1) | 1,47 ms | 1,29 ms |
| Lo stesso frame con celle lampeggianti e 3 regole di formato | 1,67 ms | 1,46 ms |
| Aggiornamenti live da un thread di lavoro in una griglia ordinata di 1.000 righe, frame renderizzati a 60 Hz | 1.000 aggiornamenti/s a 60,0 fps, 0 frame persi | 1.000 aggiornamenti/s a 60,0 fps, 0 frame persi |
| Massima frequenza di aggiornamento di un thread di lavoro mentre la stessa griglia mantiene 60 fps | 1.552.858 aggiornamenti/s | 2.001.921 aggiornamenti/s |
| Modalità server, tabella SQLite da 10.000.000 di righe: apertura fino alla prima pagina disegnata | non eseguito | 117,3 ms (2,1 ms con il conteggio stimato) |
Misurato il 2026-11-04. Le tabelle seguenti riportano il metodo, la macchina e ogni valore.
Un frame è la finestra visibile di una griglia 1920 x 1080, renderizzata senza finestra da TsgcGridRenderer sul canvas raster, lo stesso codice che disegna le griglie VCL e FireMonkey. Nel ciclo non ci sono né finestre né GPU. La griglia scorre un poco a ogni frame, come fa una griglia live. C1 e gli altri gate di frame usano la mediana di 5 esecuzioni da 60 frame dopo un riscaldamento.
Raggruppamento, filtro, ordinamento e riepiloghi vengono eseguiti sul modello dati della griglia, senza renderer. Ogni valore è la mediana di 5 esecuzioni dopo un riscaldamento, oppure il migliore di 12 esecuzioni alternate dove il gate lo indica. Ogni gate ha un budget, e l'esecuzione QA fallisce quando un valore lo supera.
Un thread di lavoro scrive aggiornamenti di prezzo con il thread safe UpdateRow, come fa la demo LiveTicker. Il thread principale renderizza un frame ogni 16,67 ms (60 Hz). Ogni frame riordina la vista modificata, come fa una griglia disegnata. Il benchmark riporta gli aggiornamenti al secondo scritti, i frame al secondo renderizzati, i frame che hanno mancato il loro slot e il tempo di rendering per frame.
TsgcGridServerProvider_DataSet pagina una tabella generata tramite FireDAC. Ogni passo termina quando le sue righe sono caricate e il frame è disegnato. Ogni valore è la mediana di 5 esecuzioni dopo un riscaldamento, con il file del database nella cache del sistema operativo. I salti cadono a 2.000 righe di distanza da un'esecuzione all'altra, così ogni esecuzione legge dal database e non dalla cache di pagine della griglia.
| CPU | Intel Core Ultra 5 245T, 14 core, 14 processori logici |
| Memoria | 31,5 GB |
| Disco | SSD NVMe, Phison 1 TB |
| Sistema operativo | Windows 11 Pro 26H2, build 26300.9711 |
| Compilatore | Delphi 13 (compilatore 37.0), build release Win32 e Win64 |
| Database | SQLite 3.42.0 tramite FireDAC, incorporato e collegato staticamente |
| Sorgenti | albero di sviluppo di sgcGrid del 2026-11-04 (revisione svn 20169 con modifiche locali) |
La macchina era una workstation di sviluppo, non un server di benchmark isolato. Ogni esecuzione pesante ha tenuto un blocco a livello di macchina, quindi nessuna build o test è stato eseguito nello stesso momento.
Il gruppo perf della suite QA di sgcGrid, eseguito da solo su Win32 e Win64. Il budget è il limite che il gate impone (Win32 / Win64).
| Gate | Cosa si misura | Win32 | Win64 | Budget |
|---|---|---|---|---|
| C1 | Frame piatto 1920 x 1080, 12 colonne, 100.000 righe | 1,47 ms | 1,29 ms | 4,09 / 4,32 ms |
| Con stile | Lo stesso frame, celle lampeggianti e 3 regole di formato (media di 60 frame) | 1,67 ms | 1,46 ms | 25 / 16 ms |
| GW3 | Frame con evidenziazioni della ricerca, 100.000 righe | 1,43 ms | 1,75 ms | 25 / 16 ms |
| GW5 | Frame con 20 colonne, 3 livelli di banda, 2 colonne bloccate, 100.000 righe | 1,62 ms | 1,42 ms | 25 / 16 ms |
| GW7 | Frame con colonne di immagine, avanzamento e sparkline a 30 punti, 100.000 righe | 2,20 ms | 3,20 ms | 25 / 16 ms |
| F1 | Frame con 2 colonne bloccate e un piè di pagina, scorso in entrambe le direzioni, 100.000 righe | 0,56 ms | 0,50 ms | 25 / 16 ms |
| G4 | Frame di 1.000.000 di righe raggruppate per 2 colonne, tutto espanso | 0,49 ms | 0,48 ms | 25 / 16 ms |
| D1 | Frame con 3 bande di dettaglio visibili da 50 righe ciascuna | 2,47 ms | 2,65 ms | 25 / 16 ms |
| G1 | Raggruppare 100.000 righe per 2 colonne, 2 riepiloghi, costruire e appiattire | 15,11 ms | 11,98 ms | 60 / 40 ms |
| G2 | Raggruppare 1.000.000 di righe per 2 colonne, 2 riepiloghi, costruire e appiattire | 155,37 ms | 132,61 ms | 700 / 450 ms |
| G3 | Espandere o comprimere un gruppo della vista da 1.000.000 di righe | 4,16 ms | 3,28 ms | 25 / 15 ms |
| G5 | Riepiloghi a piè di pagina, 5 colonne da 100.000 righe | 5,64 ms | 2,34 ms | 25 / 15 ms |
| T1 | Albero di 100.000 righe, profondità fino a 8, costruire e appiattire completamente espanso | 20,42 ms | 22,80 ms | 90 / 60 ms |
| GW0 | Ricostruzione della vista ordinata, 1.000.000 di righe | 253,45 ms | 240,29 ms | 268,24 / 259,62 ms |
| GW1 | Valori distinti di una colonna di testo con 1.000 membri, con filtro a cascata, 1.000.000 di righe | 55,61 ms | 48,42 ms | 450 / 300 ms |
| GW2 | Filtro con un elenco di 500 valori su 1.000 più una condizione, 1.000.000 di righe | 50,75 ms | 48,02 ms | 225 / 150 ms |
| M1 | Memoria della vista a righe sopra i dati, 1.000.000 di righe raggruppate per 2 colonne | 20,07 MB | 20,09 MB | 32 MB |
| X1 | Esportazione XLSX di 100.000 righe x 12 colonne, 2 livelli di gruppo, riepiloghi | 1.693,87 ms | 1.002,71 ms | 4.500 / 3.000 ms |
| L2 | Visualizzatore di log che segue la coda mentre un thread aggiunge 10.000 righe al secondo: frame disegnati al secondo | 38,87 fps | 38,67 fps | minimo 20 fps |
| L2 | La stessa esecuzione: 99° percentile del ritardo di input | 4,22 ms | 2,83 ms | 33 ms |
sgcGridBench_Live: un thread di lavoro scrive prezzo, variazione, volume e ora di una riga casuale con UpdateRow, mentre il thread principale renderizza ogni 16,67 ms una griglia ordinata e lampeggiante 1920 x 1080. 5 secondi per caso. Uno slot perso è un frame terminato dopo l'inizio del successivo.
| Righe | Frequenza obiettivo | Piattaforma | Aggiornamenti/s | Frame/s | Slot persi | Rendering, mediana | Rendering, p99 | Rendering, max |
|---|---|---|---|---|---|---|---|---|
| 1.000 | 1.000/s | Win32 | 1.000 | 60,0 | 0 | 1,28 ms | 2,46 ms | 2,57 ms |
| 1.000 | 1.000/s | Win64 | 1.000 | 60,0 | 0 | 1,36 ms | 2,41 ms | 2,45 ms |
| 1.000 | 10.000/s | Win32 | 9.998 | 60,0 | 0 | 1,43 ms | 2,79 ms | 2,98 ms |
| 1.000 | 10.000/s | Win64 | 9.998 | 60,0 | 0 | 1,29 ms | 2,46 ms | 3,17 ms |
| 1.000 | il più veloce possibile | Win32 | 1.552.858 | 60,0 | 0 | 1,26 ms | 3,09 ms | 3,35 ms |
| 1.000 | il più veloce possibile | Win64 | 2.001.921 | 60,0 | 0 | 1,26 ms | 2,54 ms | 3,28 ms |
| 100.000 | 1.000/s | Win32 | 1.000 | 60,0 | 0 | 10,52 ms | 13,72 ms | 15,92 ms |
| 100.000 | 1.000/s | Win64 | 1.000 | 60,0 | 0 | 10,50 ms | 13,99 ms | 14,68 ms |
| 100.000 | 10.000/s | Win32 | 9.966 | 47,6 | 62 | 14,70 ms | 40,33 ms | 42,03 ms |
| 100.000 | 10.000/s | Win64 | 9.997 | 54,2 | 29 | 13,59 ms | 35,10 ms | 39,86 ms |
Una griglia ordinata di 100.000 righe riordina la sua vista a ogni frame in cui la colonna ordinata è cambiata, quindi il suo tempo di rendering cresce con il numero di righe. Gli aggiornamenti di colonne non ordinate mantengono la vista, e MaxFPS può abbassare la frequenza di frame di una griglia che deve solo sembrare live.
sgcGridBench_Server su SQLite 3.42.0, Win64. La tabella ha 12 colonne di tipi misti (intero, testo, virgola mobile, data e ora, booleano), una chiave intera indicizzata e una colonna cliente indicizzata, con dati deterministici. Ogni passo termina con le righe caricate e il frame 1920 x 1080 disegnato. Mediana di 5 esecuzioni dopo un riscaldamento.
| Passo | 1.000.000 di righe | 10.000.000 di righe | Cosa viene eseguito sul database |
|---|---|---|---|
| Apertura fino alla prima pagina disegnata | 2,8 ms | 117,3 ms | Colonne dallo schema, COUNT(*) esatto, prima pagina |
| Apertura con il conteggio stimato | 2,1 ms | 2,1 ms | CountMode = gscEstimated: solo la prima pagina, il conteggio cresce finché le pagine tornano piene |
| Conteggio esatto delle righe | 0,2 ms | 115,6 ms | SELECT COUNT(*) |
| Salto al centro | 40,1 ms | 378,8 ms | Una pagina alla riga centrale, LIMIT e OFFSET |
| Salto alla fine | 75,0 ms | 735,4 ms | L'ultima pagina, LIMIT e OFFSET |
| Ordinamento per una colonna indicizzata | 2,5 ms | 119,3 ms | ORDER BY customer tramite il suo indice, più il conteggio esatto della nuova query |
| Ordinamento per una colonna senza indice | 106,9 ms | 1.169,3 ms | ORDER BY amount DESC, una scansione completa |
| Condizione del generatore di filtri | 97,5 ms | 975,7 ms | WHERE region = 'North' AND qty > 50, conteggio e prima pagina (corrispondono 40.000 e 400.000 righe) |
| Raggruppamento lato server, righe di gruppo disegnate | 266,5 ms | 3.917,8 ms | GROUP BY region (12 gruppi) con il conteggio delle righe di ogni gruppo, una scansione completa |
| Memoria del processo dopo l'esecuzione | 76,5 MB | 75,7 MB | Working set del processo di benchmark, cache di pagine di SQLite inclusa |
La griglia stessa legge solo le pagine sullo schermo, quindi il suo costo resta costante. Ciò che cresce con la tabella è il lavoro del database: il conteggio esatto, l'OFFSET di un salto profondo e un ordinamento o un raggruppamento su una colonna senza indice. Un indice sulla colonna ordinata o raggruppata, oppure il conteggio stimato, mantiene brevi quei passi. Generare la tabella da 10.000.000 di righe ha richiesto 42,5 s, e una seconda esecuzione sullo stesso file ha dato valori entro il 25% di questi.
SQL Server, PostgreSQL, Firebird e tabelle da 100.000.000 di righe sono misurati con gli stessi strumenti. I loro valori saranno aggiunti qui quando saranno stati eseguiti. Fino ad allora, per essi non viene pubblicato alcun numero.
I programmi di benchmark si trovano nella cartella QA dei sorgenti di sgcUI, QA\Grid\Bench. Sono programmi console senza progetto IDE.
build_bench.bat compila sgcGridBench_Server.exe e sgcGridBench_Live.exe per Win32 e Win64 con Delphi 13 in bin\win32 e bin\win64, e copia il file ini accanto ad essi.
sgcGridBench_Server.exe --rows=10000000 crea la tabella se manca, poi misura ogni passo e scrive un report Markdown e una riga CSV per valore. Opzioni: --ini, --rows, --runs, --db, --generate, --out.
Modifica sgcGridBench_Server.ini: DriverName è il driver FireDAC (MSSQL, PG, FB o SQLite), ogni chiave di [Params] va alla connessione, e Dialect seleziona il dialetto SQL. L'ini contiene un esempio per ogni motore.
sgcGridBench_Live.exe --seconds=5 esegue i casi live sopra. I gate del client sono il gruppo perf della suite QA, sgcGridQA.exe --group=perf, che aggiunge ogni valore a sgcGridQA_perf.txt. Eseguilo da solo su una macchina a riposo.
[Connection]
DriverName=PG
[Params]
Server=localhost
Port=5432
Database=bench
User_Name=postgres
Password=secret
[Bench]
Dialect=postgresql
Table=bench_orders
Rows=10000000
Runs=5