Premier commit
Cette révision appartient à :
révision
536792a769
62 fichiers modifiés
+6766
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur