188 lignes
9.5 KiB
Markdown
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.
|