LogoRRR 26.8.0 · measured performance

File size no longer
has to fit the Java heap.

Open a multi-gigabyte log, move to its middle, jump to its tail, and keep the Java heap bounded. The largest test file was 8 GiB with a 256 MiB Java heap.

View the measurements Download LogoRRR

$ open production.log

file: 8 GiB
Java heap limit: 256 MiB
first window: 155 ms
retained Java heap: 3.62 MiB
process PSS: 159.2 MiB

first · middle · tail ready

32×file-to-heap ratio

8 GiB file, 256 MiB Java heap

155 msto first usable window

8 GiB test with constrained memory

3.62 MiBretained Java heap

after opening the first, middle, and tail windows

69×faster to usable data

26.8.0 versus 26.2.0 with the 2 GiB fixture

Architecture

From fitting the whole file in memory to reading the part you need

Before 26.8.0, larger files meant millions more retained line objects. The out-of-core engine keeps a bounded working set and reads source windows when they are requested.

Published versions24.4 · 25.2 · 26.2

log fileevery lineJava heap

The 2 GiB fixture retained about 3.21 GiB of Java heap. With a 4 GiB fixture, all three published versions exhausted a 4 GiB Java heap.

LogoRRR26.8.0

log filebounded windowsview

After opening the first, middle, and tail windows, the 8 GiB fixture retained 3.62 MiB of Java heap—even with the heap limited to 256 MiB.

Same file · same 4 GiB Java heap

One 2 GiB log across four LogoRRR generations

Every value is the median of three successful runs after file-specific cache eviction. The smaller range shows the fastest and slowest measured run.

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

Controlled 2 GiB comparison with a maximum 4 GiB Java heap
Version	Engine	Ready	Retained Java heap	Peak PSS	Runs
24.4.0	resident	7.66 s	3.08 GiB	4.19 GiB	3
25.2.0	resident	8.41 s	3.21 GiB	4.21 GiB	3
26.2.0	resident	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

Usable data arrived 69× faster, with 918× less retained Java heap. The comparison is between 26.8.0 and the latest published version in the test, 26.2.0, using the 2 GiB fixture.

The former memory ceiling

Published versions run out of Java heap at 4 GiB; 26.8.0 continues

All versions passed the 2 GiB test with a 4 GiB Java heap. At 4 GiB, every resident engine exhausted that heap. The new engine passed both the 4 GiB and 8 GiB tests.

Controlled comparison by fixture size, with three runs for each passing cell
File	24.4.0	25.2.0	26.2.0	26.8.0
500 MiB	Passed	Passed	Passed	Passed
1 GiB	Passed	Passed	Passed	Passed
2 GiB	Passed	Passed	Passed	Passed
4 GiB	Java heap exhausted	Java heap exhausted	Java heap exhausted	Passed
8 GiB	Not rerun	Not rerun	Not rerun	Passed

Once a version exhausted its Java heap, larger fixtures were marked “not rerun” rather than repeating the same failure.

Constrained-memory test

Eight times the file size, nearly flat memory use

LogoRRR 26.8.0 ran with a 256 MiB Java heap limit. As the file grew from 1 GiB to 8 GiB, retained Java heap stayed near 3.6 MiB and total process PSS near 159 MiB.

1 GiB

first: 152 ms
middle: 13 ms
tail: 6 ms
Java heap: 3.56 MiB
PSS: 157.3 MiB

2 GiB

first: 146 ms
middle: 13 ms
tail: 7 ms
Java heap: 3.58 MiB
PSS: 160.0 MiB

4 GiB

first: 146 ms
middle: 14 ms
tail: 9 ms
Java heap: 3.59 MiB
PSS: 158.9 MiB

8 GiB

first: 155 ms
middle: 18 ms
tail: 12 ms
Java heap: 3.62 MiB
PSS: 159.2 MiB

Each value is the median of three runs. The methodology table below includes the measured ranges for every window.

The practical constraint now

Storage throughput sets the pace, not memory proportional to file size

The first window can be returned without reading the entire source. Work that must inspect every byte still depends on the drive and filesystem.

In a separate exact-search test with a 500 MiB fixture, the first match appeared after 3.38 s. Complete coverage took 34.8 s at 14.4 MiB/s.

first match3.38 s

complete coverage34.8 s

500 MiB deterministic fixture · median of three runs

Method and provenance

Repeatable measurements with conservative boundaries

The test runs real loader code from each build against deterministic, non-sparse fixtures. Every run uses a separate JVM, and process memory comes from operating-system measurements.

Controlled input

Deterministic UTF-8 log lines with a fixed width, stored in non-sparse files created before measurement.

Cold-file policy

The operating-system cache for the fixture is evicted before every run; the test does not purge the global cache.

Process memory

Retained Java heap is sampled after garbage collection. Peak proportional set size (PSS) is read from /proc/<pid>/smaps_rollup.

Two test lanes

A 4 GiB Java heap compares every version up to its failure point. A separate 256 MiB lane tests 26.8.0 with 1, 2, 4, and 8 GiB fixtures.

LogoRRR 26.8.0 with a 256 MiB Java heap; medians and measured ranges
File	First window	Middle	Tail	Retained Java heap	Peak 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

Environment

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

Builds

24.4.0 — published 2024-06-06, asset logorrr_24.4.0_arm64.deb, SHA-256 27a4aea231dc78ba4b3838cc57361728bc714926f9270731bd7637eba8dda065
25.2.0 — published 2025-12-23, asset logorrr_25.2.0_arm64.deb, SHA-256 f8de52dccb4224a25b0689aaef9d64618e98102d7134e637b249d1830c516fb1
26.2.0 — published 2026-03-03, asset logorrr_26.2.0_arm64.deb, SHA-256 cfec5dd09753ba90167199aa5d94f388448fc518f7629bf598b7debb01489cca
26.8.0 — release-ramp-down source snapshot f5e31853, built and measured as 26.8.0

Evidence identity

Comparison SHA-256: 7de25d018ba40d51504ccd265f03a5ef8167bd9ae52d543e66880444d5223024

Stress-test SHA-256: 7f480db156fd24d6fa3d6946ea24c003ae8dd54abff5a3621c646aff2b58281e

These results apply to this fixture, machine, and protocol—not to every drive or workload. “Storage-bound” means that the tested file-size ceiling is no longer proportional to retained Java heap; operations that read the full source still depend on storage throughput. Largest tested file: 8 GiB.

LogoRRR Pro

Open the log that used to be too large

Full-file access is included with LogoRRR Pro. The free preview remains deliberately limited, so you can evaluate the workflow before unlocking work with large files.

Get LogoRRR