Fichiers
ui/doc/memoire.md
T
2026-10-11 01:55:22 +02:00

188 lignes
9.5 KiB
Markdown

# Memoire — trois modes de pages, cinq arenes, un garde-fou
## 1. Les trois modes, et ce qu ils valent
L acquisition des pages (`src/proj3/mem/page_source_linux.cpp`) essaie trois
chemins **dans l ordre**, au demarrage, **dans un seul binaire** :
| ordre | appel | mode retenu |
|---|---|---|
| 1 | `mmap(MAP_HUGETLB \| MAP_HUGE_2MB)` | `HugeMode::Hugetlb2MB` |
| 2 | `mmap` classique puis `madvise(MADV_HUGEPAGE)` | `HugeMode::TransparentHuge` |
| 3 | `mmap` classique seul | `HugeMode::PlainPages` |
C est exactement l esprit du repli OpenGL/GDI de Gastinel Write : detection au
runtime, un seul binaire, aucune question a l utilisateur, et le mode
effectivement retenu est journalise et interrogeable par le programme.
### Ils n ont PAS les memes proprietes de determinisme
C est le point central, pas une note de bas de page.
**`Hugetlb2MB`** — les pages viennent du pool hugetlbfs, reservees d avance.
Elles ne sont ni deplacees, ni fusionnees, ni recuperees, ni scindees. Une
entree de TLB couvre 2 Mo. **Les mesures de latence faites dans ce mode sont
valides.**
**`TransparentHuge`** — le noyau *peut* promouvoir la region en huge pages, ou
pas. Il le fait par un fil de fond, `khugepaged`, dont l ordonnancement nous
echappe totalement. Une promotion — ou une scission — peut se produire
**pendant** une mesure. **Toute mesure de latence faite dans ce mode porte une
barre d erreur inconnue** et doit etre annotee comme telle. Le mode est
utilisable, le chiffre qui en sort ne l est pas sans reserve.
**`PlainPages`** — pages de 4 Ko. Comportement previsible, mais couvrir les
9,6 Mo de scanout demande environ 2342 entrees de TLB, ce qui depasse la TLB
de second niveau d un Cortex-A75. Les manques de TLB deviennent alors une
source de variance mesurable. **Le mode est correct, pas rapide.**
**`HostEmulated`** — cible hote uniquement, memoire fournie par `malloc`.
Aucune garantie d aucune sorte. Ce mode existe pour que le harnais tourne sur
la machine de dev, et pour qu il soit **impossible** de confondre un chiffre
obtenu sur un x86 de bureau avec un chiffre obtenu sur le telephone.
### Savoir lequel est actif
```cpp
#include "proj3/mem/page_source.hpp"
proj3::mem::HugeMode m = proj3::mem::active_mode();
const char* nom = proj3::mem::huge_mode_name(m); // "HUGETLB-2MB", ...
bool mesurable = proj3::mem::mode_is_deterministic(m); // true pour Hugetlb2MB seul
proj3::mem::log_active_mode(); // journalise + avertit
```
`log_active_mode()` ecrit sur la sortie d erreur, au demarrage, quelque chose
comme :
```
proj3: memoire : mode retenu = PAGES-4K
proj3: memoire : ATTENTION, pages NON garanties.
proj3: memoire : toute mesure de latence faite dans ce mode
proj3: memoire : porte une barre d erreur inconnue.
```
### Attention : `MAP_HUGETLB` n est pas suppose disponible
Sa presence sur le noyau stock du Pixel 3a **n a pas ete verifiee
materiellement**. Sur un noyau Android par defaut, `nr_hugepages` vaut zero et
le pool est vide : le chemin 1 echouera avec `ENOMEM`. C est precisement
pourquoi le repli existe et pourquoi il est teste des le premier demarrage.
`MAP_HUGE_2MB` est passe explicitement. Sans lui, `MAP_HUGETLB` utilise la
taille de huge page par defaut du systeme, qui peut valoir 512 Mo sur certaines
configurations arm64 — l appel echouerait alors pour une raison difficile a
diagnostiquer.
## 2. Les cinq arenes
Un **seul** `mmap` est fait, puis decoupe. Raison : le repli huge pages ne vaut
que sur une region contigue. Cinq `mmap` separes auraient cinq modes
potentiellement differents, et la question « quel mode est actif ? » n aurait
plus de reponse unique.
Toutes les tailles sont dans `src/proj3/mem/layout.hpp`, en `constexpr`, avec
leur calcul. Dimensionnement **Pixel 3a : 4 Go de RAM, 1080x2220**.
| arene | taille | calcul |
|---|---:|---|
| `scanout` | 19 185 664 | `1080*2220*4 = 9 590 400` par tampon, arrondi a la page (9 592 832), **deux** tampons. Double buffering, pas triple : un troisieme tampon ajoute une image entiere de latence, ce que le projet combat. |
| `geometrie` | 2 097 152 | Une arete = 20 octets. Pire cas raisonne : ~600 points de contour, chaque quadratique subdivisee au plus 64 fois -> 38 400 aretes = 768 000 octets. 2 Mo laisse la place d y ajouter un trace d interface dans la meme passe. |
| `atlas` | 2 097 152 | Couverture 8 bits. Trois corps (16/24/32 px), cellule `(corps+2)^2` : 324 + 676 + 1156 = 2156 octets par glyphe. 256 glyphes (Latin-1 + ponctuation) = 551 936 octets. Facteur 3,8 de marge pour un quatrieme corps ou une graisse. |
| `entree` | 131 072 | Evenement normalise = 32 octets. Ecran tactile : ~200 evt/s par contact, 10 contacts = 2000 evt/s. 4096 emplacements = plus de deux secondes de rafale. |
| `scratch` | 2 097 152 | Remis a zero a chaque image. Majorant des intersections de balayage : 38 400 croisements de 8 octets = 307 200 octets, plus les tampons de composition par tuiles. |
**Total decoupe : 25 608 192 octets.** Le bloc demande au noyau est arrondi au
multiple superieur de 2 Mo — `MAP_HUGETLB` exige une longueur multiple de la
taille de huge page — soit **27 262 976 octets (26 Mo)**. Le reliquat de
1 654 784 octets n est pas perdu : il est expose comme `kReserveBytes`.
Soit **0,63 % des 4 Go du Pixel 3a**.
### Comportement
- Allocation = avance de pointeur, avec alignement calcule **sur l offset** et
non sur l adresse. La base d une arene etant alignee sur 2 Mo, cela revient
au meme — mais cela rend le comportement rigoureusement identique entre
l hote et la cible, ce qui compte pour le harnais d oracle.
- **Pas de liberation individuelle.** Un `reset()` global par arene, un
`mark()` / `rewind_to()` pour les usages en pile.
- **Un debordement est une panique**, jamais un agrandissement. Le message
donne le nom de l arene, la taille demandee, l alignement, l occupation et la
capacite :
```
proj3: PANIQUE: debordement d arene 'geometrie' : demande=4194304 align=8 occupe=0 capacite=2097152
Un debordement d arene est un defaut de conception, pas un cas
a gerer : corriger le calcul dans mem/layout.hpp.
```
- `Arena::peak()` donne la plus haute occupation atteinte. C est la seule
metrique qui permette de dire si une taille de `layout.hpp` est juste ou
fantaisiste. Cout : une comparaison par allocation.
## 3. Le garde-fou
`src/proj3/mem/new_guard.cpp` redefinit `operator new`, `operator new[]`,
`operator delete`, `operator delete[]`, ainsi que leurs formes dimensionnees et
alignees. Toutes tuent le processus immediatement :
```
proj3: ALLOCATION INTERDITE: operator new[] taille=64
Le projet n alloue rien apres l init. Tout passe par une arene
(mem/arena.hpp). Poser un point d arret sur operator new et
remonter la pile pour trouver l appelant.
```
Code de sortie **71**, distinct du **70** de `panic()`, pour qu un script sache
que c est une allocation et pas autre chose.
**Ce que le garde-fou n attrape pas**, et il faut le savoir :
- `malloc` / `calloc` / `realloc` / `free` appeles directement. Ce sont des
fonctions C, sans rapport avec `operator new`. Sur la cible embarquee la
question ne se pose pas (le lien echouerait). Sur l hote,
`page_source_host.cpp` les utilise deliberement.
- les allocations faites par le noyau (pile, `mmap`) ;
- les VLA et `alloca`, qui prennent sur la pile.
Le perimetre est donc exactement : **aucun `new` C++ nulle part**. C est ce
qu on veut verifier.
**Il est en bibliotheque separee** (`proj3_newguard`) et n est lie qu aux
executables qui pretendent ne rien allouer. Le lier partout casserait tout
outil utilisant la STL de l hote — ce qui est le comportement recherche, mais
doit etre choisi executable par executable.
Preuve qu il fonctionne : `test/test_new_guard.cpp`, declare `WILL_FAIL TRUE`
dans CTest. Le test est reussi si et seulement si le processus meurt.
## 4. A REVERIFIER lors du passage a la cible 12 Go (Poco F5 Pro)
Cette section est le point de reprise. Rien de ce qui suit n est fait.
1. **La resolution change.** Le Poco F5 Pro est en 1440x3200. Le calcul du
scanout devient `1440*3200*4 = 18 432 000` par tampon, soit **36 Mo pour
deux** au lieu de 19 Mo. `kScreenWidth` / `kScreenHeight` doivent devenir
des parametres, pas des constantes — et la question « constexpr ou lu depuis
DRM ? » se posera : une taille lue au runtime interdit le dimensionnement
`constexpr` des arenes, ce qui est un changement d architecture, pas un
ajustement.
2. **La taille de page peut differer.** Certains noyaux arm64 recents sont
compiles en pages de 16 Ko. `kPageSize` doit alors changer ; `kHugePageSize`
passerait de 2 Mo (PMD sur 4K) a 32 Mo (PMD sur 16K), ce qui invaliderait
`MAP_HUGE_2MB`.
3. **`MAP_HUGETLB` a peut-etre plus de chances d aboutir** sur un noyau plus
recent — ou pas. A verifier materiellement, pas a supposer. Si le mode 1
devient disponible sur une cible et pas sur l autre, les mesures des deux
cibles ne sont **pas comparables entre elles**.
4. **Les tailles d atlas et de geometrie ne doivent PAS etre augmentees
mecaniquement.** Elles sont dimensionnees par un raisonnement (nombre de
glyphes, nombre d aretes), pas par un pourcentage de la RAM. Plus de RAM ne
justifie pas plus d atlas ; une densite de pixels plus elevee, qui impose des
corps plus grands, oui — et il faudra refaire le calcul, pas le doubler.
5. **`kArenaTotal < RAM/64` deviendra trivialement vrai** et cessera d etre un
garde-fou utile. Le remplacer par une borne absolue reflechie.
6. **Le pic reel doit etre releve avant de retoucher quoi que ce soit.**
`Arena::peak()` existe pour cela. Redimensionner sans avoir regarde les pics
sur la cible actuelle serait du reglage a l aveugle.