// mem/page_source.hpp — acquisition des pages, avec repli detecte au runtime. // // UN SEUL BINAIRE, TROIS CHEMINS, choisis a l execution : // // 1. mmap(MAP_HUGETLB | MAP_HUGE_2MB) -> HugeMode::Hugetlb2MB // 2. mmap classique + madvise(MADV_HUGEPAGE) -> HugeMode::TransparentHuge // 3. mmap classique seul -> HugeMode::PlainPages // // Meme esprit que le repli OpenGL/GDI de Gastinel Write : on ne compile pas // deux binaires, on ne demande pas a l utilisateur, on essaie dans l ordre et // on journalise ce qui a marche. // // CES TROIS MODES N ONT PAS LES MEMES PROPRIETES DE DETERMINISME. // C est le point central de ce fichier, pas une note de bas de page : // // Hugetlb2MB Les pages sont reservees d avance dans le pool hugetlbfs. // Elles ne sont ni deplacees, ni fusionnees, ni recuperees. // 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, // et il le fait par un fil de fond (khugepaged) dont // l ordonnancement nous echappe. 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. // // PlainPages Pages de 4 Ko. Le comportement est previsible mais le // nombre d entrees de TLB necessaires pour couvrir le // scanout (9,6 Mo, soit ~2342 pages) depasse la TLB L2 d un // Cortex-A75. Les manques de TLB sont alors une source de // variance mesurable. Le mode est correct, pas rapide. // // C est pourquoi active_mode() est expose dans l API : tout code qui produit // une mesure doit pouvoir l estampiller. #pragma once #include "proj3/base/types.hpp" namespace proj3::mem { enum class HugeMode : u32 { Uninitialized = 0, Hugetlb2MB, TransparentHuge, PlainPages, // Cible hote uniquement : memoire fournie par la libc de l hote. Aucune // garantie d aucune sorte. Presente pour que le harnais puisse tourner // sur la machine de dev, et pour qu il soit IMPOSSIBLE de confondre une // mesure faite ici avec une mesure faite sur la cible. HostEmulated, }; struct PageBlock { u8* base = nullptr; usize size = 0; HugeMode mode = HugeMode::Uninitialized; }; // Nom lisible, pour la journalisation. Jamais nullptr. const char* huge_mode_name(HugeMode m); // true si le mode donne autorise a publier une mesure de latence sans // avertissement. Un seul mode repond true. constexpr bool mode_is_deterministic(HugeMode m) { return m == HugeMode::Hugetlb2MB; } // Acquiert `size` octets. `size` doit etre un multiple de 2 Mo (exige par // MAP_HUGETLB ; on impose la meme contrainte aux trois chemins pour que le // mode retenu ne change pas la disposition memoire). // Rend false uniquement si les TROIS chemins ont echoue. bool page_acquire(usize size, PageBlock& out); // Rend les pages. N est appele qu en fin de processus, et meme la c est // superflu (le noyau nettoie). Existe pour que le harnais hote puisse // enchainer plusieurs acquisitions sans fuir. void page_release(PageBlock& block); // Mode effectivement retenu par la derniere acquisition reussie. // Interrogeable par le programme, comme demande. HugeMode active_mode(); // Journalise sur la sortie d erreur le mode retenu et ses implications. void log_active_mode(); } // namespace proj3::mem