Fichiers
ui/test/test_arena.cpp
T
2026-10-11 01:55:22 +02:00

123 lignes
4.4 KiB
C++

// 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<uptr>(p16) & 15u) == 0, "alignement 16 respecte");
check((reinterpret_cast<uptr>(p64) & 63u) == 0, "alignement 64 respecte");
}
// --- Avance de pointeur -------------------------------------------------
{
mem::Arena& a = sys.scratch;
a.reset();
u8* x = a.alloc_array<u8>(100);
u8* y = a.alloc_array<u8>(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<u8>(500);
const usize m = a.mark();
(void)a.alloc_array<u8>(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<u8>(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<usize>(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<i64>(mem::kArenaTotal));
err_write(" octets\n");
err_write("echecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}