// test/test_arena.cpp — arenes et acquisition de pages (chantier 3). // // S execute sur la machine de dev. Il ne teste PAS le repli huge pages, qui // demande un vrai noyau Linux : sur l hote, page_acquire rend toujours // HostEmulated. Ce que ce test verifie, c est la logique d arene elle-meme, // qui est du code portable partage a l identique par les deux cibles. #include "proj3/mem/layout.hpp" #include "proj3/mem/system.hpp" #include "proj3/sys/panic.hpp" using namespace proj3; namespace { int g_failures = 0; void check(bool cond, const char* what) { err_write(cond ? "OK " : "ECHEC "); err_write(what); err_write("\n"); if (!cond) ++g_failures; } } // namespace int main() { err_write("=== arenes ===\n\n"); static mem::System sys; check(mem::system_init(sys), "system_init"); mem::log_active_mode(); err_write("\n"); check(sys.scanout.capacity() == mem::kScanoutBytes, "taille de l arene scanout"); check(sys.scanout.used() == 0, "arene neuve : occupation nulle"); // --- Alignement --------------------------------------------------------- { mem::Arena& a = sys.scratch; a.reset(); (void)a.alloc(1, 1); // desaligne volontairement la suite void* p16 = a.alloc(8, 16); void* p64 = a.alloc(8, 64); check((reinterpret_cast(p16) & 15u) == 0, "alignement 16 respecte"); check((reinterpret_cast(p64) & 63u) == 0, "alignement 64 respecte"); } // --- Avance de pointeur ------------------------------------------------- { mem::Arena& a = sys.scratch; a.reset(); u8* x = a.alloc_array(100); u8* y = a.alloc_array(100); check(y == x + 100, "allocations contigues sans alignement force"); check(a.used() == 200, "occupation exacte"); } // --- mark / rewind ------------------------------------------------------ { mem::Arena& a = sys.scratch; a.reset(); (void)a.alloc_array(500); const usize m = a.mark(); (void)a.alloc_array(1000); check(a.used() == 1500, "occupation apres deux allocations"); a.rewind_to(m); check(a.used() == 500, "rewind_to restitue la position"); } // --- reset -------------------------------------------------------------- { mem::Arena& a = sys.scratch; (void)a.alloc_array(1000); const usize peak_before = a.peak(); a.reset(); check(a.used() == 0, "reset remet l occupation a zero"); check(a.peak() == peak_before, "reset ne remet PAS le pic a zero"); } // --- Borne : try_alloc rend nullptr au lieu de paniquer ----------------- // On ne peut pas tester alloc() directement : par conception, il tue le // processus. C est exactement ce que verifie test_new_guard pour operator // new ; ici on se contente de la variante non fatale. { mem::Arena& a = sys.input; a.reset(); void* p = a.try_alloc(a.capacity() + 1, 1); check(p == nullptr, "try_alloc au-dela de la capacite rend nullptr"); check(a.used() == 0, "un try_alloc refuse ne consomme rien"); void* q = a.try_alloc(a.capacity(), 1); check(q != nullptr, "try_alloc de la capacite exacte reussit"); check(a.remaining() == 0, "arene pleine : reste nul"); check(a.try_alloc(1, 1) == nullptr, "arene pleine : un octet de plus est refuse"); } // --- Debordement arithmetique ------------------------------------------- { mem::Arena& a = sys.input; a.reset(); const usize huge = ~static_cast(0) - 8; check(a.try_alloc(huge, 16) == nullptr, "taille absurde refusee sans reboucler"); } // --- Le budget annonce correspond au budget decoupe --------------------- { const usize sum = sys.scanout.capacity() + sys.geometry.capacity() + sys.atlas.capacity() + sys.input.capacity() + sys.scratch.capacity(); check(sum == mem::kArenaTotalRaw, "somme des arenes == kArenaTotalRaw"); check(sum + mem::kReserveBytes == mem::kArenaTotal, "reserve coherente"); } err_write("\nbudget total demande au noyau : "); err_write_i64(static_cast(mem::kArenaTotal)); err_write(" octets\n"); err_write("echecs : "); err_write_i64(g_failures); err_write("\n"); return g_failures == 0 ? 0 : 1; }