9.5 KiB
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
#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, unmark()/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 delayout.hppest 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/freeappeles directement. Ce sont des fonctions C, sans rapport avecoperator new. Sur la cible embarquee la question ne se pose pas (le lien echouerait). Sur l hote,page_source_host.cpples 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.
- La resolution change. Le Poco F5 Pro est en 1440x3200. Le calcul du
scanout devient
1440*3200*4 = 18 432 000par tampon, soit 36 Mo pour deux au lieu de 19 Mo.kScreenWidth/kScreenHeightdoivent devenir des parametres, pas des constantes — et la question « constexpr ou lu depuis DRM ? » se posera : une taille lue au runtime interdit le dimensionnementconstexprdes arenes, ce qui est un changement d architecture, pas un ajustement. - La taille de page peut differer. Certains noyaux arm64 recents sont
compiles en pages de 16 Ko.
kPageSizedoit alors changer ;kHugePageSizepasserait de 2 Mo (PMD sur 4K) a 32 Mo (PMD sur 16K), ce qui invalideraitMAP_HUGE_2MB. MAP_HUGETLBa 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.- 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.
kArenaTotal < RAM/64deviendra trivialement vrai et cessera d etre un garde-fou utile. Le remplacer par une borne absolue reflechie.- 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.