LogoRRR 26.8.0 · prestazioni misurate

Il file non deve più
entrare interamente nella Java heap.

Apri un log da più GiB, passa al centro o vai in coda: la Java heap resta limitata. Il file più grande del test era di 8 GiB, con una Java heap di 256 MiB.

Vedi le misurazioni Scarica LogoRRR

$ open production.log

file: 8 GiB
limite Java heap: 256 MiB
prima finestra: 155 ms
Java heap trattenuta: 3.62 MiB
PSS del processo: 159.2 MiB

inizio · centro · coda disponibili

32×rapporto file/Java heap

file da 8 GiB, Java heap da 256 MiB

155 msalla prima finestra utilizzabile

test da 8 GiB con memoria limitata

3.62 MiBJava heap trattenuta

dopo aver aperto inizio, centro e coda

69×più rapido ai primi dati utilizzabili

26.8.0 rispetto a 26.2.0 sul file da 2 GiB

Architettura

Dall’intero file in memoria alla sola parte necessaria

Prima della 26.8.0, un file più grande comportava direttamente milioni di oggetti-riga in più da trattenere. Il motore out-of-core mantiene un insieme di lavoro limitato e legge dalla sorgente le finestre richieste.

Versioni pubblicate24.4 · 25.2 · 26.2

file di logtutte le righeJava heap

Il file di test da 2 GiB tratteneva circa 3,21 GiB di Java heap. Con un file da 4 GiB, tutte e tre le versioni pubblicate hanno esaurito una Java heap da 4 GiB.

LogoRRR26.8.0

file di logfinestre limitatevista

Dopo l’accesso all’inizio, al centro e alla coda del file da 8 GiB, la Java heap trattenuta era di soli 3.62 MiB, con un limite di 256 MiB.

Stesso file · stessa Java heap da 4 GiB

Un log da 2 GiB in quattro generazioni di LogoRRR

Ogni valore è la mediana di tre esecuzioni riuscite dopo l’espulsione della cache specifica del file. L’intervallo più piccolo mostra l’esecuzione misurata più veloce e quella più lenta.

24.4.0

7.66 s7541–8876 ms

25.2.0

8.41 s8243–8511 ms

26.2.0

9.89 s9863–10607 ms

26.8.0

144 ms143–150 ms

Confronto controllato su 2 GiB con un massimo di 4 GiB di Java heap
Versione	Motore	Pronto	Java heap trattenuta	Picco PSS	Esecuzioni
24.4.0	residente	7.66 s	3.08 GiB	4.19 GiB	3
25.2.0	residente	8.41 s	3.21 GiB	4.21 GiB	3
26.2.0	residente	9.89 s	3.21 GiB	4.21 GiB	3
26.8.0	out-of-core	144 ms	3.58 MiB	159.2 MiB	3

Dati utilizzabili 69 volte più rapidamente, con una Java heap trattenuta 918 volte inferiore. Il confronto usa il file da 2 GiB e mette 26.8.0 a confronto con la versione pubblicata più recente del test, la 26.2.0.

Il precedente limite di memoria

Le versioni pubblicate esauriscono la Java heap a 4 GiB; 26.8.0 prosegue

Con una Java heap da 4 GiB, tutte le versioni hanno superato il test da 2 GiB. Con un file da 4 GiB, ogni motore residente ha esaurito quella memoria. Il nuovo motore ha superato sia il test da 4 GiB sia quello da 8 GiB.

Confronto controllato per dimensione del file; tre esecuzioni per ogni cella superata
File	24.4.0	25.2.0	26.2.0	26.8.0
500 MiB	Superato	Superato	Superato	Superato
1 GiB	Superato	Superato	Superato	Superato
2 GiB	Superato	Superato	Superato	Superato
4 GiB	Java heap esaurita	Java heap esaurita	Java heap esaurita	Superato
8 GiB	Non rieseguito	Non rieseguito	Non rieseguito	Superato

Quando una versione esauriva la Java heap, i file più grandi venivano indicati come «non rieseguito» invece di ripetere lo stesso errore.

Test con memoria limitata

File otto volte più grande, memoria quasi invariata

LogoRRR 26.8.0 è stato eseguito con una Java heap limitata a 256 MiB. Mentre il file cresceva da 1 GiB a 8 GiB, la Java heap trattenuta è rimasta intorno a 3,6 MiB e la PSS totale del processo intorno a 159 MiB.

1 GiB

inizio: 152 ms
centro: 13 ms
coda: 6 ms
Java heap: 3.56 MiB
PSS: 157.3 MiB

2 GiB

inizio: 146 ms
centro: 13 ms
coda: 7 ms
Java heap: 3.58 MiB
PSS: 160.0 MiB

4 GiB

inizio: 146 ms
centro: 14 ms
coda: 9 ms
Java heap: 3.59 MiB
PSS: 158.9 MiB

8 GiB

inizio: 155 ms
centro: 18 ms
coda: 12 ms
Java heap: 3.62 MiB
PSS: 159.2 MiB

Ogni valore è la mediana di tre esecuzioni. La tabella metodologica seguente riporta gli intervalli misurati per ogni finestra.

Il limite pratico attuale

Il ritmo dipende dallo storage, non da una memoria proporzionale al file

La prima finestra può essere restituita senza leggere l’intera sorgente. Le operazioni che devono esaminare ogni byte dipendono ancora dall’unità e dal file system.

In un test separato di ricerca esatta su un file da 500 MiB, la prima corrispondenza è arrivata dopo 3.38 s. La copertura completa ha richiesto 34.8 s a 14.4 MiB/s.

prima corrispondenza3.38 s

copertura completa34.8 s

file deterministico da 500 MiB · mediana di tre esecuzioni

Metodo e provenienza

Misurazioni ripetibili con limiti volutamente prudenti

Il test esegue il vero codice del caricatore di ogni build su file deterministici non sparsi. Ogni esecuzione usa una JVM separata e i dati sulla memoria del processo provengono dal sistema operativo.

Input controllato

Righe di log UTF-8 deterministiche e a larghezza fissa, salvate in file non sparsi creati prima della misurazione.

Criterio per il file a freddo

Prima di ogni esecuzione viene espulsa la cache del sistema operativo relativa al file; la cache globale non viene svuotata.

Memoria del processo

La Java heap trattenuta viene rilevata dopo la garbage collection. Il picco di proportional set size (PSS) viene letto da /proc/<pid>/smaps_rollup.

Due serie di test

Una Java heap da 4 GiB confronta tutte le versioni fino al rispettivo punto di errore. Una serie separata limita 26.8.0 a 256 MiB e la verifica con file da 1, 2, 4 e 8 GiB.

LogoRRR 26.8.0 con 256 MiB di Java heap; mediane e intervalli misurati
File	Prima finestra	Centro	Coda	Java heap trattenuta	Picco PSS
1 GiB	152 ms 149–159	13 ms 12–14	6 ms 6–7	3.56 MiB	157.3 MiB
2 GiB	146 ms 143–146	13 ms 12–13	7 ms 7–7	3.58 MiB	160.0 MiB
4 GiB	146 ms 141–153	14 ms 13–15	9 ms 9–10	3.59 MiB	158.9 MiB
8 GiB	155 ms 153–157	18 ms 15–18	12 ms 12–12	3.62 MiB	159.2 MiB

Ambiente

Ubuntu 24.04.4 LTS, aarch64, 8 logical CPUs, openjdk version "25.0.2" 2026-01-20.

Build

24.4.0 — pubblicata il 2024-06-06, artefatto logorrr_24.4.0_arm64.deb, SHA-256 27a4aea231dc78ba4b3838cc57361728bc714926f9270731bd7637eba8dda065
25.2.0 — pubblicata il 2025-12-23, artefatto logorrr_25.2.0_arm64.deb, SHA-256 f8de52dccb4224a25b0689aaef9d64618e98102d7134e637b249d1830c516fb1
26.2.0 — pubblicata il 2026-03-03, artefatto logorrr_26.2.0_arm64.deb, SHA-256 cfec5dd09753ba90167199aa5d94f388448fc518f7629bf598b7debb01489cca
26.8.0 — snapshot del codice nella fase finale della release f5e31853, compilata e misurata come 26.8.0

Identità dei dati

SHA-256 del confronto: 7de25d018ba40d51504ccd265f03a5ef8167bd9ae52d543e66880444d5223024

SHA-256 dello stress test: 7f480db156fd24d6fa3d6946ea24c003ae8dd54abff5a3621c646aff2b58281e

Questi risultati descrivono questo file, questa macchina e questo protocollo, non ogni unità o carico di lavoro. «Limitato dallo storage» significa che la dimensione massima testata non è più proporzionale alla Java heap trattenuta; le operazioni sull’intera sorgente dipendono ancora dalla velocità dello storage. File più grande testato: 8 GiB.

LogoRRR Pro

Apri il log che prima era troppo grande

L’accesso al file completo è incluso in LogoRRR Pro. L’anteprima gratuita resta volutamente limitata, così puoi valutare il flusso di lavoro prima di sbloccare i file di grandi dimensioni.

Ottieni LogoRRR