# 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.