LogoRRR 26.8.0 · performances mesurées

La taille du fichier n’a plus
à tenir dans la Java heap.

Ouvrez un journal de plusieurs GiB, passez au milieu ou à la fin : la Java heap reste bornée. Le plus grand fichier testé faisait 8 GiB avec une Java heap limitée à 256 MiB.

Voir les mesures Télécharger LogoRRR

$ open production.log

fichier: 8 GiB
limite de Java heap: 256 MiB
première fenêtre: 155 ms
Java heap conservée: 3.62 MiB
PSS du processus: 159.2 MiB

début · milieu · fin disponibles

32×rapport fichier/Java heap

fichier de 8 GiB, Java heap de 256 MiB

155 msavant la première fenêtre exploitable

test de 8 GiB en mémoire contrainte

3.62 MiBJava heap conservée

après consultation du début, du milieu et de la fin

69×plus rapide jusqu’aux premières données

26.8.0 face à 26.2.0 sur le fichier de 2 GiB

Architecture

Du fichier entier en mémoire à la lecture de la seule zone utile

Avant 26.8.0, chaque fichier plus grand ajoutait directement des millions d’objets de ligne conservés. Le moteur out-of-core maintient un jeu de travail borné et lit à la demande les zones demandées dans la source.

Versions publiées24.4 · 25.2 · 26.2

fichier journaltoutes les lignesJava heap

Le fichier de 2 GiB conservait environ 3,21 GiB de Java heap. Avec un fichier de 4 GiB, les trois versions publiées ont épuisé une Java heap de 4 GiB.

LogoRRR26.8.0

fichier journalfenêtres bornéesvue

Après consultation du début, du milieu et de la fin du fichier de 8 GiB, la Java heap conservée n’était que de 3.62 MiB, avec une limite fixée à 256 MiB.

Même fichier · même Java heap de 4 GiB

Un journal de 2 GiB dans quatre générations de LogoRRR

Chaque valeur est la médiane de trois exécutions réussies après éviction du cache propre au fichier. La petite plage indique les exécutions mesurées la plus rapide et la plus lente.

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

Comparaison contrôlée sur 2 GiB avec une Java heap maximale de 4 GiB
Version	Moteur	Prêt	Java heap conservée	Pic de PSS	Exécutions
24.4.0	résident	7.66 s	3.08 GiB	4.19 GiB	3
25.2.0	résident	8.41 s	3.21 GiB	4.21 GiB	3
26.2.0	résident	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

Données exploitables 69 fois plus vite, avec 918 fois moins de Java heap conservée. La comparaison porte sur 26.8.0 et la version publiée la plus récente du test, 26.2.0, avec le fichier de 2 GiB.

L’ancienne limite mémoire

Les versions publiées épuisent la Java heap à 4 GiB ; 26.8.0 continue

Avec une Java heap de 4 GiB, toutes les versions ont réussi le test à 2 GiB. Sur un fichier de 4 GiB, tous les moteurs résidents ont épuisé cette mémoire. Le nouveau moteur a réussi les tests à 4 GiB et à 8 GiB.

Comparaison contrôlée par taille de fichier ; trois exécutions pour chaque case réussie
Fichier	24.4.0	25.2.0	26.2.0	26.8.0
500 MiB	Réussi	Réussi	Réussi	Réussi
1 GiB	Réussi	Réussi	Réussi	Réussi
2 GiB	Réussi	Réussi	Réussi	Réussi
4 GiB	Java heap épuisée	Java heap épuisée	Java heap épuisée	Réussi
8 GiB	Non relancé	Non relancé	Non relancé	Réussi

Lorsqu’une version avait épuisé sa Java heap, les fichiers plus grands étaient marqués « non relancé » plutôt que de reproduire le même échec.

Test en mémoire contrainte

Un fichier huit fois plus grand, une mémoire presque stable

LogoRRR 26.8.0 était limité à 256 MiB de Java heap. Quand le fichier est passé de 1 GiB à 8 GiB, la Java heap conservée est restée proche de 3,6 MiB et la PSS totale du processus d’environ 159 MiB.

1 GiB

début: 152 ms
milieu: 13 ms
fin: 6 ms
Java heap: 3.56 MiB
PSS: 157.3 MiB

2 GiB

début: 146 ms
milieu: 13 ms
fin: 7 ms
Java heap: 3.58 MiB
PSS: 160.0 MiB

4 GiB

début: 146 ms
milieu: 14 ms
fin: 9 ms
Java heap: 3.59 MiB
PSS: 158.9 MiB

8 GiB

début: 155 ms
milieu: 18 ms
fin: 12 ms
Java heap: 3.62 MiB
PSS: 159.2 MiB

Chaque valeur est la médiane de trois exécutions. Le tableau méthodologique ci-dessous présente les plages mesurées pour chaque fenêtre.

La contrainte pratique actuelle

Le stockage donne le rythme, pas une mémoire proportionnelle au fichier

La première fenêtre peut être fournie sans lire toute la source. Les opérations qui doivent examiner chaque octet dépendent toujours du disque et du système de fichiers.

Lors d’un test distinct de recherche exacte sur un fichier de 500 MiB, le premier résultat est apparu après 3.38 s. La couverture complète a pris 34.8 s, à 14.4 MiB/s.

premier résultat3.38 s

couverture complète34.8 s

fichier déterministe de 500 MiB · médiane de trois exécutions

Méthode et provenance

Des mesures reproductibles aux limites volontairement prudentes

Le test exécute le véritable code de chargement de chaque build sur des fichiers déterministes non creux. Chaque exécution dispose de sa propre JVM et les mesures de mémoire du processus proviennent du système d’exploitation.

Entrée contrôlée

Lignes de journal UTF-8 déterministes et de largeur fixe, stockées dans des fichiers non creux créés avant la mesure.

Politique de fichier froid

Le cache du système d’exploitation propre au fichier est évincé avant chaque exécution ; le cache global n’est pas purgé.

Mémoire du processus

La Java heap conservée est relevée après le ramasse-miettes. Le pic de taille proportionnelle (PSS) est lu dans /proc/<pid>/smaps_rollup.

Deux séries de tests

Une Java heap de 4 GiB compare toutes les versions jusqu’à leur point d’échec. Une série distincte limite 26.8.0 à 256 MiB et le teste avec des fichiers de 1, 2, 4 et 8 GiB.

LogoRRR 26.8.0 avec 256 MiB de Java heap ; médianes et plages mesurées
Fichier	Première fenêtre	Milieu	Fin	Java heap conservée	Pic de 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

Environnement

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

Builds

24.4.0 — publié le 2024-06-06, fichier logorrr_24.4.0_arm64.deb, SHA-256 27a4aea231dc78ba4b3838cc57361728bc714926f9270731bd7637eba8dda065
25.2.0 — publié le 2025-12-23, fichier logorrr_25.2.0_arm64.deb, SHA-256 f8de52dccb4224a25b0689aaef9d64618e98102d7134e637b249d1830c516fb1
26.2.0 — publié le 2026-03-03, fichier logorrr_26.2.0_arm64.deb, SHA-256 cfec5dd09753ba90167199aa5d94f388448fc518f7629bf598b7debb01489cca
26.8.0 — instantané du code source en fin de préparation de version f5e31853, compilé et mesuré comme 26.8.0

Identité des preuves

SHA-256 de la comparaison: 7de25d018ba40d51504ccd265f03a5ef8167bd9ae52d543e66880444d5223024

SHA-256 du test de charge: 7f480db156fd24d6fa3d6946ea24c003ae8dd54abff5a3621c646aff2b58281e

Ces résultats décrivent ce fichier, cette machine et ce protocole, pas tous les disques ni toutes les charges. « Limité par le stockage » signifie que la taille maximale testée n’est plus proportionnelle à la Java heap conservée ; les opérations sur toute la source dépendent toujours du débit de stockage. Plus grand fichier testé : 8 GiB.

LogoRRR Pro

Ouvrez le journal qui était jusqu’ici trop volumineux

L’accès au fichier complet fait partie de LogoRRR Pro. L’aperçu gratuit reste volontairement limité afin d’évaluer le flux de travail avant de débloquer les fichiers volumineux.

Obtenir LogoRRR