Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:55:22 +02:00
révision 536792a769
62 fichiers modifiés
+6766

Aucun fichier ne correspond à votre recherche

+57
Voir le fichier
@@ -0,0 +1,57 @@
// test/oracle/main.cpp — point d entree du harnais d oracle.
//
// Le meme fichier sert aux deux cibles :
// hote -> main(), executable proj3_oracle
// embarquee -> proj3_main(), executable proj3_oracle_target
//
// Code de sortie : 0 si toutes les paires concordent, 1 sinon. Rien d autre,
// pour qu il soit utilisable tel quel par ctest ou par un script.
#include "oracle.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
static int oracle_entry() {
err_write("=== harnais d oracle proj3 ===\n");
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("impossible d acquerir la memoire de travail\n");
return 1;
}
oracle::g_system = &sys;
mem::log_active_mode();
err_write("\n");
oracle::Report rep;
const bool ok = oracle::run_all(sys.scratch, rep);
err_write("\npaires comparees : ");
err_write_i64(rep.pairs_run);
err_write("\npaires en reference seule : ");
err_write_i64(rep.pairs_ref_only);
err_write("\ncas executes : ");
err_write_i64(rep.cases_run);
err_write("\ncas en echec : ");
err_write_i64(rep.cases_failed);
err_write(ok ? "\nRESULTAT : concordance totale\n" : "\nRESULTAT : DIVERGENCE\n");
// Pic d occupation du scratch : verifie que le dimensionnement de
// mem/layout.hpp tient, y compris sous le harnais.
err_write("pic scratch : ");
err_write_i64(static_cast<i64>(sys.scratch.peak()));
err_write(" / ");
err_write_i64(static_cast<i64>(sys.scratch.capacity()));
err_write("\n");
return ok ? 0 : 1;
}
#if PROJ3_EMBEDDED
extern "C" int proj3_main(int, char**) { return oracle_entry(); }
#else
int main() { return oracle_entry(); }
#endif
+243
Voir le fichier
@@ -0,0 +1,243 @@
#include "oracle.hpp"
#include "proj3/base/fmt.hpp"
#include "proj3/base/mem.hpp"
#include "proj3/sys/panic.hpp"
namespace proj3::oracle {
mem::System* g_system = nullptr;
namespace {
// Octet de garde ecrit apres chaque tampon de sortie. Toute routine qui ecrit
// un octet de trop l ecrase, et le harnais le voit. C est ce qui transforme
// le cas "debordement d un octet" en detection, au lieu d une corruption
// silencieuse d une zone voisine.
constexpr u8 kGuardByte = 0xA5;
constexpr usize kGuardBytes = 32;
// Motif deterministe, pour les cas de graine 0. Volontairement non trivial
// (ni tout a zero ni croissant) pour qu une routine qui ignore son entree ne
// passe pas par chance.
void fill_deterministic(u8* p, usize n) {
for (usize i = 0; i < n; ++i) {
p[i] = static_cast<u8>((i * 31u + (i >> 3) * 17u + 0x5Bu) & 0xFFu);
}
}
void fill_random(u8* p, usize n, u64 seed) {
Rng rng(seed);
usize i = 0;
while (i < n) {
u64 v = rng.next();
for (int b = 0; b < 8 && i < n; ++b, ++i) {
p[i] = static_cast<u8>(v & 0xFFu);
v >>= 8;
}
}
}
void dump_hex(const u8* p, usize n) {
char buf[3];
for (usize i = 0; i < n; ++i) {
const usize k = fmt_hex_u8(buf, sizeof(buf), p[i]);
err_write_bytes(buf, k);
buf[0] = ' ';
err_write_bytes(buf, 1);
}
}
// Contexte autour de l offset divergent : 16 octets avant, 16 apres, bornes au
// tampon. Sans contexte, un offset seul ne dit pas si l erreur est un decalage
// ou une valeur fausse.
void dump_context(const char* tag, const u8* p, usize len, usize center) {
const usize begin = center >= 16 ? center - 16 : 0;
usize end = center + 17;
if (end > len) end = len;
err_write(" ");
err_write(tag);
err_write(" [");
err_write_i64(static_cast<i64>(begin));
err_write("..");
err_write_i64(static_cast<i64>(end));
err_write(") : ");
dump_hex(p + begin, end - begin);
err_write("\n");
}
bool guards_intact(const u8* guard) {
for (usize i = 0; i < kGuardBytes; ++i) {
if (guard[i] != kGuardByte) return false;
}
return true;
}
// --- Enregistrement --------------------------------------------------------
#if PROJ3_EMBEDDED
// Symboles synthetises par l editeur de liens pour la section proj3_pairs.
extern "C" const Pair* const __start_proj3_pairs[];
extern "C" const Pair* const __stop_proj3_pairs[];
#else
// Stockage statique a initialisation constante : il est pret AVANT que le
// moindre constructeur statique ne tourne, donc l ordre d initialisation ne
// peut pas nous mordre.
constexpr usize kMaxPairs = 64;
const Pair* g_pairs[kMaxPairs];
usize g_pair_count;
#endif
} // namespace
void register_pair(const Pair* p) {
#if PROJ3_EMBEDDED
(void)p; // l enregistrement se fait par la section, pas par appel
#else
if (g_pair_count >= kMaxPairs) panic("oracle : trop de paires enregistrees");
g_pairs[g_pair_count++] = p;
#endif
}
bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure) {
bool pair_ok = true;
if (p.opt == nullptr) {
++out.pairs_ref_only;
} else {
++out.pairs_run;
}
for (usize ci = 0; ci < p.case_count; ++ci) {
const CaseSpec& c = p.cases[ci];
const usize mark = work.mark();
// Tampons : chacun precede de son decalage d alignement et suivi d une
// zone de garde. La base de l arene est alignee sur 2 Mo, donc un
// decalage de k octets donne une adresse ≡ k modulo 16 : c est
// exactement le levier dont les chemins NEON auront besoin.
u8* in_raw = work.alloc_array<u8>(c.in_len + 64);
u8* in = in_raw + c.in_align_offset;
const usize out_cap = c.in_len;
u8* ref_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
u8* ref_out = ref_raw + c.out_align_offset;
u8* ref_guard = ref_out + out_cap;
u8* opt_raw = work.alloc_array<u8>(out_cap + 64 + kGuardBytes);
u8* opt_out = opt_raw + c.out_align_offset;
u8* opt_guard = opt_out + out_cap;
if (c.seed == 0) {
fill_deterministic(in, c.in_len);
} else {
fill_random(in, c.in_len, c.seed);
}
mem_fill(ref_out, 0, out_cap);
mem_fill(opt_out, 0, out_cap);
mem_fill(ref_guard, kGuardByte, kGuardBytes);
mem_fill(opt_guard, kGuardByte, kGuardBytes);
const usize ref_len = p.ref(in, c.in_len, ref_out, out_cap);
++out.cases_run;
bool case_ok = true;
const char* reason = nullptr;
usize diff_at = 0;
if (!guards_intact(ref_guard)) {
case_ok = false;
reason = "la REFERENCE a deborde son tampon de sortie";
}
if (case_ok && p.opt != nullptr) {
const usize opt_len = p.opt(in, c.in_len, opt_out, out_cap);
if (!guards_intact(opt_guard)) {
case_ok = false;
reason = "l implementation optimisee a deborde son tampon";
} else if (opt_len != ref_len) {
case_ok = false;
reason = "longueur de sortie differente";
} else {
diff_at = mem_first_diff(ref_out, opt_out, ref_len);
if (diff_at != ref_len) {
case_ok = false;
reason = "octet divergent";
}
}
if (!case_ok) {
err_write("ECHEC ");
err_write(p.name);
err_write(" / ");
err_write(c.label);
err_write("\n ");
err_write(reason);
err_write("\n");
err_write(" rejouer ce cas : graine=");
err_write_i64(static_cast<i64>(c.seed));
err_write(" in_len=");
err_write_i64(static_cast<i64>(c.in_len));
err_write(" align_in=+");
err_write_i64(c.in_align_offset);
err_write(" align_out=+");
err_write_i64(c.out_align_offset);
err_write("\n");
err_write(" longueurs : reference=");
err_write_i64(static_cast<i64>(ref_len));
err_write(" optimisee=");
err_write_i64(static_cast<i64>(opt_len));
err_write("\n");
if (diff_at < ref_len) {
err_write(" premier octet divergent a l offset ");
err_write_i64(static_cast<i64>(diff_at));
err_write(" : attendu=");
err_write_hex(ref_out[diff_at]);
err_write(" obtenu=");
err_write_hex(opt_out[diff_at]);
err_write("\n");
dump_context("attendu", ref_out, ref_len, diff_at);
dump_context("obtenu ", opt_out, opt_len, diff_at);
}
}
}
if (!case_ok) {
++out.cases_failed;
pair_ok = false;
}
work.rewind_to(mark);
}
if (pair_ok) {
err_write(p.opt == nullptr ? "REF " : "OK ");
err_write(p.name);
if (p.opt == nullptr) {
err_write(" (reference figee, version assembleur absente)");
}
err_write("\n");
}
// Un self-test attend un echec : dans ce cas, "reussi" veut dire "a bien
// echoue". Sans cette inversion, on ne saurait pas prouver que le harnais
// sait detecter une erreur connue.
return expect_failure ? !pair_ok : pair_ok;
}
bool run_all(mem::Arena& work, Report& out) {
bool ok = true;
#if PROJ3_EMBEDDED
for (const Pair* const* it = __start_proj3_pairs; it != __stop_proj3_pairs; ++it) {
if (!run_pair(**it, work, out, false)) ok = false;
}
#else
for (usize i = 0; i < g_pair_count; ++i) {
if (!run_pair(*g_pairs[i], work, out, false)) ok = false;
}
#endif
return ok;
}
} // namespace proj3::oracle
+134
Voir le fichier
@@ -0,0 +1,134 @@
// test/oracle/oracle.hpp — harnais de validation croisee C++ / assembleur.
//
// METHODE (doc/methode-oracle.md) :
// Toute routine critique existe en deux exemplaires : une reference C++ qui
// marche, et une version assembleur qui va vite. Le harnais les execute sur
// les MEMES entrees et compare les sorties OCTET PAR OCTET. Pas d epsilon,
// pas de tolerance. La reference C++ n est jamais supprimee.
//
// AJOUTER UNE PAIRE : ecrire deux fonctions de signature RunFn, un tableau de
// CaseSpec, et une ligne PROJ3_ORACLE_PAIR. Aucun fichier du harnais n est a
// modifier. C est la condition pour qu il serve encore dans six mois.
#pragma once
#include "proj3/base/types.hpp"
#include "proj3/mem/arena.hpp"
#include "proj3/mem/system.hpp"
namespace proj3::oracle {
// Arenes du programme, publiees pour que les paires puissent s en servir sans
// que la signature RunFn ait a les transporter. Positionne par le point
// d entree avant run_all(). Une paire qui l utilise doit rembobiner ce qu elle
// prend (mark/rewind_to) : le harnais ne le fait que pour SES tampons.
extern mem::System* g_system;
// Signature unique de toute routine testable.
// in / in_len : entree en lecture seule
// out / out_cap : sortie, deja remise a zero par le harnais
// retour : nombre d octets ecrits (compare lui aussi)
//
// Tout passe par des octets. Une routine qui manipule des structures les
// reinterprete depuis `in` : c est volontairement fruste, parce que c est ce
// qui permet a UN harnais de comparer n importe quelle paire sans savoir de
// quoi elle parle.
using RunFn = usize (*)(const u8* in, usize in_len, u8* out, usize out_cap);
struct CaseSpec {
const char* label;
usize in_len;
// Graine du generateur pseudo-aleatoire. 0 = cas deterministe explicite :
// l entree est remplie par un motif fixe (voir fill_deterministic).
u64 seed;
// Decalage applique a la base des tampons, en octets, pour forcer un
// desalignement. Les routines NEON auront des chemins differents selon
// l alignement : il faut pouvoir tester les deux.
u8 in_align_offset;
u8 out_align_offset;
};
struct Pair {
const char* name;
RunFn ref;
// nullptr autorise : la paire existe, la version assembleur n est pas
// encore ecrite. Le harnais execute alors la reference seule (pour
// verifier qu elle ne plante ni n alloue) et signale la paire comme
// "reference figee, asm absent". C est ce qui permet d enregistrer une
// routine AVANT d avoir son asm, comme demande au chantier 5.
RunFn opt;
const CaseSpec* cases;
usize case_count;
};
// --- Enregistrement --------------------------------------------------------
//
// Deux mecanismes, un par cible, derriere la meme macro :
//
// Cible embarquee : les pointeurs de paires sont places dans une section ELF
// nommee `proj3_pairs`. L editeur de liens synthetise automatiquement
// __start_proj3_pairs / __stop_proj3_pairs pour toute section dont le nom
// est un identifiant C valide. AUCUN constructeur statique n est
// necessaire — c est indispensable ici, puisque asm/start.S ne parcourt
// pas .init_array (cf. ADR-0001).
//
// Cible hote : le format PE de MinGW ne synthetise pas ces symboles. On
// retombe sur un constructeur statique qui chaine la paire dans une liste.
// L hote, lui, a un vrai demarrage C++ : c est sans risque.
//
// L asymetrie est laide mais elle est confinee a ces vingt lignes, et elle
// evite d imposer un enregistrement manuel qui, lui, serait oublie.
void register_pair(const Pair* p);
struct Registrar {
explicit Registrar(const Pair* p) { register_pair(p); }
};
#if PROJ3_EMBEDDED
#define PROJ3_ORACLE_PAIR(ident, name_str, ref_fn, opt_fn, cases_arr) \
static const ::proj3::oracle::Pair ident##_pair = { \
name_str, ref_fn, opt_fn, cases_arr, \
sizeof(cases_arr) / sizeof(cases_arr[0])}; \
__attribute__((used, section("proj3_pairs"))) static const ::proj3::oracle::Pair* \
const ident##_slot = &ident##_pair
#else
#define PROJ3_ORACLE_PAIR(ident, name_str, ref_fn, opt_fn, cases_arr) \
static const ::proj3::oracle::Pair ident##_pair = { \
name_str, ref_fn, opt_fn, cases_arr, \
sizeof(cases_arr) / sizeof(cases_arr[0])}; \
static const ::proj3::oracle::Registrar ident##_slot(&ident##_pair)
#endif
// --- Execution -------------------------------------------------------------
struct Report {
u32 pairs_run = 0;
u32 pairs_ref_only = 0;
u32 cases_run = 0;
u32 cases_failed = 0;
};
// Execute toutes les paires enregistrees. `work` fournit les tampons.
// Rend true si aucune divergence.
bool run_all(mem::Arena& work, Report& out);
// Execute UNE paire donnee, sans passer par l enregistrement. Sert au
// self-test du harnais (prouver qu il rejette une implementation fausse).
bool run_pair(const Pair& p, mem::Arena& work, Report& out, bool expect_failure);
// Generateur pseudo-aleatoire reproductible : xorshift64*.
// Choisi parce qu il tient en quatre lignes, n a aucun etat cache, et donne
// exactement la meme suite sur AArch64 et sur x86-64 (arithmetique entiere
// 64 bits non signee uniquement, aucun flottant).
struct Rng {
u64 state;
explicit constexpr Rng(u64 seed) : state(seed == 0 ? 0x9E3779B97F4A7C15ull : seed) {}
u64 next() {
state ^= state >> 12;
state ^= state << 25;
state ^= state >> 27;
return state * 0x2545F4914F6CDD1Dull;
}
};
} // namespace proj3::oracle
+69
Voir le fichier
@@ -0,0 +1,69 @@
// test/oracle/pairs_demo.cpp — paire de demonstration du harnais.
//
// Elle sert a deux choses et rien d autre :
// 1. montrer a quoi ressemble l ajout d une paire (trois declarations, une
// macro, aucun fichier du harnais touche) ;
// 2. donner au self-test une erreur CONNUE a detecter.
#include "oracle.hpp"
extern "C" {
proj3::usize proj3_fill_bytes_asm(const proj3::u8* in, proj3::usize in_len,
proj3::u8* out, proj3::usize out_cap);
proj3::usize proj3_fill_bytes_asm_broken(const proj3::u8* in, proj3::usize in_len,
proj3::u8* out, proj3::usize out_cap);
}
namespace proj3::oracle {
// Version de reference C++. Elle est la definition de ce qui est correct.
// Elle n est JAMAIS supprimee, meme quand l assembleur est valide.
usize fill_bytes_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (in_len == 0) return 0;
const u8 value = in[0];
for (usize i = 0; i < out_cap; ++i) out[i] = value;
return out_cap;
}
// Jeu de cas. Les explicites d abord, les aleatoires ensuite.
//
// Ce qui est couvert et pourquoi :
// - taille nulle : le cas ou une boucle mal ecrite ecrit quand meme
// - 1 octet : pas de corps de boucle vectorisable
// - 15 / 16 / 17 : juste sous, sur, et juste au-dessus d une ligne
// NEON de 128 bits
// - 63 / 64 / 65 : idem pour une ligne de cache
// - desalignements +1 +7 +9 : entree et sortie desalignees separement, puis
// ensemble, parce qu un chemin NEON qui n aligne
// qu un cote existe et est faux
// - tailles aleatoires : ce a quoi on n a pas pense
const CaseSpec kFillCases[] = {
{"vide", 0, 0, 0, 0},
{"un octet", 1, 0, 0, 0},
{"15 (sous 128 bits)", 15, 0, 0, 0},
{"16 (128 bits pile)", 16, 0, 0, 0},
{"17 (128 bits +1)", 17, 0, 0, 0},
{"63 (sous une ligne)", 63, 0, 0, 0},
{"64 (une ligne pile)", 64, 0, 0, 0},
{"65 (une ligne +1)", 65, 0, 0, 0},
{"256 aligne", 256, 0, 0, 0},
{"256 entree +1", 256, 0, 1, 0},
{"256 sortie +1", 256, 0, 0, 1},
{"256 les deux +7/+9", 256, 0, 7, 9},
{"aleatoire 1021", 1021, 0x1234'5678'9ABC'DEF0ull, 0, 0},
{"aleatoire 1021 +3/+5", 1021, 0x0F0F'0F0F'0F0F'0F0Full, 3, 5},
{"aleatoire 4096", 4096, 0xDEAD'BEEF'CAFE'BABEull, 0, 0},
};
// --- L ajout d une paire tient en une ligne -------------------------------
PROJ3_ORACLE_PAIR(fill_bytes, "fill_bytes", &fill_bytes_ref, &proj3_fill_bytes_asm,
kFillCases);
// La paire fausse n est PAS enregistree ici : elle ne doit pas faire echouer
// la suite normale. Le self-test la construit a la main.
extern const Pair kBrokenPair;
const Pair kBrokenPair = {"fill_bytes (VERSION FAUSSE)", &fill_bytes_ref,
&proj3_fill_bytes_asm_broken, kFillCases,
sizeof(kFillCases) / sizeof(kFillCases[0])};
} // namespace proj3::oracle
+197
Voir le fichier
@@ -0,0 +1,197 @@
// test/oracle/pairs_render.cpp — enregistrement des routines du pipeline de
// rendu comme REFERENCES FIGEES.
//
// Aucune version assembleur n existe encore (chantier 5 : « Pas de version
// assembleur du rasterizer dans cette passe »). C est precisement pour cela
// que ces paires sont enregistrees maintenant, avec opt = nullptr :
//
// - le harnais execute la reference sur tous les cas, ce qui verifie qu elle
// ne plante pas, ne deborde pas son tampon, et n alloue rien (le garde-fou
// du chantier 3 est lie a cet executable) ;
// - le jour ou la version NEON arrive, il n y a qu un pointeur a remplir.
// Personne n a a se demander comment brancher le test : il est deja la.
//
// Enregistrer une routine AVANT d avoir son assembleur est la seule facon
// d etre sur que le harnais sera utilise. Construit apres coup, il ne l est
// jamais.
#include "oracle.hpp"
#include "proj3/render/compose.hpp"
#include "proj3/render/rasterizer.hpp"
namespace proj3::oracle {
namespace {
// --- Glyphe synthetique ----------------------------------------------------
// Le harnais ne doit dependre d aucun fichier : il doit tourner sur la machine
// de dev, sur un Raspberry Pi, dans un conteneur, sans police installee. On
// fabrique donc un glyphe a partir des octets d entree.
//
// Forme : un rectangle exterieur (sens horaire) et un rectangle interieur
// (sens anti-horaire), plus un arc quadratique. C est le minimum qui exerce
// vraiment le nonzero winding : si la regle etait mal portee, le rectangle
// interieur ne serait pas creuse et la difference sauterait aux yeux.
constexpr u32 kSynthPointCount = 12;
constexpr u32 kSynthContourCount = 2;
struct SynthGlyph {
font::GlyphPoint points[kSynthPointCount];
u32 contour_end[kSynthContourCount];
font::Glyph glyph;
};
void build_synth(SynthGlyph& g, const u8* in, usize in_len) {
// Deux octets d entree pilotent la geometrie. Bornes pour rester dans des
// valeurs de police plausibles et pour que le glyphe ne soit jamais vide.
const f32 w = 200.0f + static_cast<f32>(in_len > 0 ? in[0] : 0u) * 2.0f;
const f32 h = 300.0f + static_cast<f32>(in_len > 1 ? in[1] : 0u) * 2.0f;
const f32 inset = 40.0f + static_cast<f32>(in_len > 2 ? (in[2] & 0x3Fu) : 0u);
auto P = [](f32 x, f32 y, bool on) {
font::GlyphPoint p;
p.x = x;
p.y = y;
p.on_curve = on;
return p;
};
// Contour exterieur : rectangle avec un cote superieur bombe (un point de
// controle off-curve), 6 points.
g.points[0] = P(0.0f, 0.0f, true);
g.points[1] = P(w, 0.0f, true);
g.points[2] = P(w, h, true);
g.points[3] = P(w * 0.5f, h + 80.0f, false); // controle quadratique
g.points[4] = P(0.0f, h, true);
g.points[5] = P(0.0f, h * 0.5f, true);
g.contour_end[0] = 6;
// Contour interieur, oriente en sens inverse : c est lui que le nonzero
// doit creuser. 6 points aussi, pour garder un tableau simple.
const f32 x0 = inset, x1 = w - inset;
const f32 y0 = inset, y1 = h - inset;
g.points[6] = P(x0, y0, true);
g.points[7] = P(x0, y1, true);
g.points[8] = P((x0 + x1) * 0.5f, y1 + 20.0f, false);
g.points[9] = P(x1, y1, true);
g.points[10] = P(x1, y0, true);
g.points[11] = P((x0 + x1) * 0.5f, y0 - 20.0f, false);
g.contour_end[1] = 12;
g.glyph = font::Glyph{};
g.glyph.points = g.points;
g.glyph.contour_end = g.contour_end;
g.glyph.point_count = kSynthPointCount;
g.glyph.contour_count = kSynthContourCount;
g.glyph.advance_width = w + 100.0f;
}
// --- Paire 1 : rasterization ----------------------------------------------
usize rasterize_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (g_system == nullptr) return 0;
SynthGlyph g;
build_synth(g, in, in_len);
// Taille en pixels pilotee par l entree, bornee a des corps realistes.
const f32 px = 8.0f + static_cast<f32>(in_len > 3 ? (in[3] & 0x3Fu) : 16u);
mem::Arena& scratch = g_system->geometry;
mem::Arena& store = g_system->atlas;
const usize m_scratch = scratch.mark();
const usize m_store = store.mark();
render::RasterizedGlyph rg;
const bool ok = render::rasterize_glyph(g.glyph, 1000, px, store, scratch, rg);
usize written = 0;
if (ok) {
// On publie la couverture brute, plus les trois metriques en tete :
// une divergence de bearing ou d avance doit etre detectee au meme
// titre qu une divergence de pixel.
const i32 meta[3] = {rg.bearing_x, rg.bearing_y, rg.advance};
const u8* meta_bytes = reinterpret_cast<const u8*>(meta);
for (usize i = 0; i < sizeof(meta) && written < out_cap; ++i) {
out[written++] = meta_bytes[i];
}
const usize n = rg.coverage.size_bytes();
for (usize i = 0; i < n && written < out_cap; ++i) {
out[written++] = rg.coverage.pixels[i];
}
}
store.rewind_to(m_store);
scratch.rewind_to(m_scratch);
return written;
}
// Les tailles sont choisies pour que la couverture depasse largement out_cap
// dans les petits cas (on ne compare alors que le prefixe) et la remplisse
// dans les grands.
const CaseSpec kRasterCases[] = {
{"entree vide", 0, 0, 0, 0},
{"4 octets", 4, 0, 0, 0},
{"64 octets", 64, 0, 0, 0},
{"4 Ko", 4096, 0, 0, 0},
{"4 Ko desaligne +1/+3", 4096, 0, 1, 3},
{"aleatoire 4 Ko", 4096, 0xA5A5'5A5A'0F0F'F0F0ull, 0, 0},
{"aleatoire 16 Ko", 16384, 0x0123'4567'89AB'CDEFull, 0, 0},
};
PROJ3_ORACLE_PAIR(raster_glyph, "render::rasterize_glyph (glyphe synthetique)",
&rasterize_ref, nullptr, kRasterCases);
// --- Paire 2 : composition -------------------------------------------------
// Separee de la rasterization, comme le code l est : c est cette routine-la
// qui deviendra un noyau NEON en premier.
usize compose_ref(const u8* in, usize in_len, u8* out, usize out_cap) {
if (g_system == nullptr || out_cap < 16) return 0;
// Framebuffer minuscule ecrit directement dans `out` : on compare donc
// exactement les octets que la routine produit, sans recopie.
const i32 fw = 32;
const i32 fh = static_cast<i32>(out_cap / (4u * 32u));
if (fh <= 0) return 0;
render::Framebuffer fb;
fb.pixels = reinterpret_cast<u32*>(out);
fb.width = fw;
fb.height = fh;
// out est aligne par le harnais selon out_align_offset ; compose_coverage
// exige 4 octets. On refuse proprement si l alignement ne convient pas,
// plutot que de paniquer : ce cas fait partie de ce qu on veut tester.
if ((reinterpret_cast<uptr>(out) & 3u) != 0) return 0;
render::framebuffer_clear(fb, 0xFF000000u);
mem::Arena& store = g_system->atlas;
const usize m = store.mark();
render::Coverage8 cov = render::coverage_alloc(store, 16, 16);
for (usize i = 0; i < cov.size_bytes(); ++i) {
cov.pixels[i] = (i < in_len && (in[i] & 1u) != 0) ? 255 : 0;
}
// Trois positions : entierement dedans, a cheval sur le bord droit, a
// cheval sur le coin haut-gauche (coordonnees negatives).
render::compose_coverage(fb, 2, 2, cov, 0xFFFFFFFFu);
render::compose_coverage(fb, fw - 8, 4, cov, 0xFF00FF00u);
render::compose_coverage(fb, -6, -6, cov, 0xFFFF0000u);
store.rewind_to(m);
return static_cast<usize>(fw) * static_cast<usize>(fh) * 4u;
}
const CaseSpec kComposeCases[] = {
{"1 ligne", 128, 0, 0, 0},
{"8 lignes", 1024, 0, 0, 0},
{"32 lignes", 4096, 0, 0, 0},
{"32 lignes aleatoire", 4096, 0xFEED'FACE'DEAD'C0DEull, 0, 0},
};
PROJ3_ORACLE_PAIR(compose_cov, "render::compose_coverage", &compose_ref, nullptr,
kComposeCases);
} // namespace
} // namespace proj3::oracle
+76
Voir le fichier
@@ -0,0 +1,76 @@
// test/oracle/selftest_main.cpp — VALIDATION DU HARNAIS LUI-MEME.
//
// « Un harnais qui ne sait pas detecter une erreur connue ne vaut rien. »
//
// Ce programme fait deux passes :
// 1. la paire correcte doit etre ACCEPTEE ;
// 2. la paire volontairement fausse (un octet de decalage) doit etre
// REJETEE, avec un diagnostic exploitable affiche a l ecran.
//
// Il rend 0 seulement si les deux attentes sont satisfaites. Un harnais qui
// accepterait la version fausse ferait echouer ce test, ce qui est le but.
//
// Ce binaire NE LIE PAS proj3_newguard : il doit afficher son diagnostic
// jusqu au bout, et l on ne veut pas qu une allocation de la libc dans printf
// vienne brouiller le resultat du test qui nous interesse ici.
#include "oracle.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace proj3::oracle {
usize fill_bytes_ref(const u8* in, usize in_len, u8* out, usize out_cap);
extern const Pair kBrokenPair;
} // namespace proj3::oracle
extern "C" {
proj3::usize proj3_fill_bytes_asm(const proj3::u8*, proj3::usize, proj3::u8*, proj3::usize);
}
int main() {
err_write("=== self-test du harnais d oracle ===\n\n");
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("impossible d acquerir la memoire de travail\n");
return 1;
}
// --- Passe 1 : la version correcte doit passer -------------------------
err_write("passe 1 : la version assembleur CORRECTE doit etre acceptee\n");
const oracle::Pair good = {"fill_bytes (version correcte)", &oracle::fill_bytes_ref,
&proj3_fill_bytes_asm, oracle::kBrokenPair.cases,
oracle::kBrokenPair.case_count};
oracle::Report rep_good;
const bool good_ok = oracle::run_pair(good, sys.scratch, rep_good, /*expect_failure=*/false);
err_write(good_ok ? " -> acceptee, comme attendu\n\n"
: " -> REJETEE ALORS QU ELLE EST CORRECTE (harnais casse)\n\n");
// --- Passe 2 : la version fausse doit etre rejetee ---------------------
err_write("passe 2 : la version assembleur FAUSSE doit etre rejetee\n");
err_write(" (defaut injecte : un octet de moins ecrit, longueur rendue correcte)\n");
err_write(" le diagnostic ci-dessous est celui que le harnais produirait\n");
err_write(" sur un vrai bug ; c est lui qu on evalue :\n\n");
oracle::Report rep_bad;
const bool bad_ok =
oracle::run_pair(oracle::kBrokenPair, sys.scratch, rep_bad, /*expect_failure=*/true);
err_write("\n");
err_write(bad_ok ? " -> rejetee, comme attendu\n"
: " -> ACCEPTEE ALORS QU ELLE EST FAUSSE (harnais inutile)\n");
err_write(" cas en echec detectes : ");
err_write_i64(rep_bad.cases_failed);
err_write(" / ");
err_write_i64(rep_bad.cases_run);
err_write("\n");
err_write(" (les cas de longueur nulle ne peuvent pas diverger : c est normal\n");
err_write(" qu ils ne comptent pas dans les echecs)\n");
const bool ok = good_ok && bad_ok;
err_write(ok ? "\nRESULTAT : le harnais discrimine correctement\n"
: "\nRESULTAT : LE HARNAIS EST DEFAILLANT\n");
return ok ? 0 : 1;
}