123 lignes
4.4 KiB
C++
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;
|
|
}
|