commit 536792a769e1efd551a1a4071895dc76be772d68 Author: Théo Gastinel <264859180+gastinelt@users.noreply.github.com> Date: Sun Oct 11 01:55:22 2026 +0200 Premier commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1e92f2f --- /dev/null +++ b/.gitignore @@ -0,0 +1,70 @@ +build*/ +*.o +*.obj +*.exe + +# --- double-push : exclusions generiques (secrets, builds, binaires, gros fichiers) --- +target/ +node_modules/ +build/ +build-*/ +dist/ +out/ +.gradle/ +.idea/ +venv/ +.venv/ +env/ +__pycache__/ +*.pyc +.cache/ +.next/ +.env +.env.* +!.env.example +accounts.json +Clee.API/ +*.pem +*.key +*.p12 +*.pfx +*.jks +*.keystore +keystore.properties +id_rsa* +id_ed25519* +*.kdbx +*.odt +*.sqlite +*.sqlite3 +*.db +*.log +*.exe +*.dll +*.msi +*.jar +*.zip +*.7z +*.rar +*.tar +*.tar.gz +*.tgz +*.gguf +*.safetensors +*.onnx +*.pt +*.pth +*.bin +*.iso +*.gws +*.apk +*.aab +*.so +*.o +*.a +*.lib +*.pdb +*.mp4 +*.mkv +*.wav +*.flac diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..c3bd42c --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,46 @@ +CONTEXTE PROJET + +Environnement graphique déterministe pour ARM64 (AArch64), sur noyau Linux. +Cible de prototypage : Google Pixel 3a (nom de code sargo, Snapdragon 670, +4 Go de RAM, driver DRM msm mainline). Cible ultérieure : Poco F5 Pro +(mondrian, SD 8+ Gen 1). Le code doit rester portable entre les deux. + +Le nom officiel du projet N'EST PAS ARRÊTÉ. N'en invente aucun. Utilise le +placeholder `proj3` pour les namespaces, préfixes et noms de dossiers, et +signale dans ton rapport tous les endroits où un vrai nom devra être +substitué plus tard. + +TROIS PILIERS — contraintes de conception, pas des objectifs vagues + +1. Déterminisme de latence. Ce qui compte n'est pas le débit moyen mais la + variance. Toute construction qui introduit une variabilité non bornée est + à rejeter, même si elle est plus rapide en moyenne. + +2. Budget mémoire explicite. Aucune allocation dynamique après la phase + d'init. Tout est préalloué en arènes de taille fixe. Pas de free, pas de + realloc, pas de conteneur qui pousse. + +3. Accès direct justifié. Chaque couche d'abstraction traversée doit être + justifiée explicitement. Pas de libc, pas de framework, pas de dépendance + externe. Les appels système passent par nos propres wrappers. + +CONTRAINTES TECHNIQUES NON NÉGOCIABLES + +- C++20, compilé avec `-nostdlib -fno-exceptions -fno-rtti -fno-threadsafe-statics`. +- Aucune dépendance externe. Aucune libc. Pas de STL (les headers purement + compile-time comme sont tolérés, à signaler s'ils sont utilisés). +- Zéro warning avec `-Wall -Wextra`. +- Toute dette technique, tout compromis, tout écart par rapport à ces + consignes doit être documenté explicitement dans le code ET dans le README. + Jamais implicite. +- Si une consigne te semble techniquement impossible ou contre-productive, + DIS-LE dans ton rapport au lieu de la contourner silencieusement. + +MÉTHODE + +- Reste strictement dans le périmètre du chantier demandé. Ne fais pas + "tant qu'on y est". +- Livrable systématique : rapport détaillé de ce qui a été fait, ce qui reste + en stub, ce qui est bloquant, et les décisions que tu as dû prendre seul. +- N'affirme jamais qu'une chose est vérifiée si tu ne l'as pas réellement + exécutée. Distingue explicitement "écrit" de "compilé" de "testé". \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..e7695b5 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,192 @@ +# CMakeLists.txt — racine. +# +# DEUX CIBLES, ASYMETRIQUES ET ASSUMEES (cf. README, section "Double cible") : +# +# * cible EMBARQUEE (aarch64-linux, freestanding) : le vrai produit. +# -nostdlib, pas de libc, point d entree _start maison, syscalls maison. +# Selectionnee par -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-linux.cmake +# +# * cible HOTE (la machine de dev, quelle qu elle soit) : outillage. +# Le harnais d oracle et les generateurs de references. Cette cible A LE +# DROIT d utiliser la libc de l hote. Elle ne produit JAMAIS de binaire +# livre. Aucun fichier compile pour la cible embarquee ne doit dependre de +# ce que la cible hote s autorise. +# +# Le partage de code entre les deux se fait uniquement par les fichiers listes +# dans proj3_portable_sources : ceux-la sont freestanding par construction. + +cmake_minimum_required(VERSION 3.20) +project(proj3 LANGUAGES CXX ASM) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + set(PROJ3_EMBEDDED ON) +else() + set(PROJ3_EMBEDDED OFF) +endif() + +# --------------------------------------------------------------------------- +# Sources portables : compilables a l identique par les deux cibles. +# Aucune de ces unites n inclut d en-tete systeme ni de libc. +# --------------------------------------------------------------------------- +set(proj3_portable_sources + src/proj3/mem/arena.cpp + src/proj3/mem/system.cpp + src/proj3/font/ttf.cpp + src/proj3/render/rasterizer.cpp + src/proj3/render/compose.cpp +) + +# -fno-math-errno : sans lui, __builtin_sqrt genere un APPEL a sqrt() de la +# libm, uniquement pour pouvoir positionner errno sur une entree negative. +# Avec lui, le compilateur emet l instruction machine (fsqrt / sqrtsd) et rien +# d autre. C est indispensable en freestanding — le lien echoue sinon — et +# c est sans effet sur la precision : contrairement au reste de -ffast-math, +# cette option ne change ni le mode d arrondi, ni l associativite, ni le +# traitement des NaN. Elle est passee aux DEUX cibles, pour que l hote et la +# cible calculent rigoureusement pareil (cf. doc/methode-oracle.md). +set(proj3_common_flags + -std=c++20 -fno-exceptions -fno-rtti -fno-threadsafe-statics + -fno-math-errno + -Wall -Wextra -O2 +) + +# =========================================================================== +# CIBLE EMBARQUEE +# =========================================================================== +if(PROJ3_EMBEDDED) + + separate_arguments(_p3_triple UNIX_COMMAND "${PROJ3_TARGET_TRIPLE_FLAGS}") + separate_arguments(_p3_linkdrv UNIX_COMMAND "${PROJ3_LINK_DRIVER_FLAGS}") + + # Tout binaire embarque partage exactement le meme socle : meme _start, + # memes wrappers syscall, meme garde-fou, meme allocateur. On le factorise + # dans une fonction pour qu il soit impossible qu un executable de test + # soit construit avec des reglages differents du binaire livre. + function(proj3_add_embedded_executable target) + add_executable(${target} + asm/start.S + asm/syscall.S + asm/demo_fill_aarch64.S + src/proj3/base/cstring.cpp + src/proj3/sys/panic.cpp + src/proj3/mem/new_guard.cpp + src/proj3/mem/page_source_linux.cpp + ${proj3_portable_sources} + ${ARGN} + ) + target_include_directories(${target} PRIVATE src) + target_compile_options(${target} PRIVATE + ${_p3_triple} + $<$:${proj3_common_flags}> + $<$:-nostdlib;-ffreestanding;-fno-builtin> + $<$:-Wall> + ) + target_compile_definitions(${target} PRIVATE PROJ3_EMBEDDED=1) + target_link_options(${target} PRIVATE + ${_p3_triple} ${_p3_linkdrv} + -nostdlib -nostartfiles -static -Wl,-e,_start -Wl,--build-id=none + ) + endfunction() + + # Le binaire livre. + proj3_add_embedded_executable(proj3_boot src/proj3/boot/main.cpp) + + # Harnais des wrappers syscall (chantier 2). S execute sur n importe quel + # Linux AArch64 : Raspberry Pi, VM, conteneur, qemu-user. Pas de telephone. + proj3_add_embedded_executable(proj3_test_syscalls test/test_syscalls.cpp) + + # Harnais d oracle, version embarquee : c est la SEULE facon d executer + # reellement les versions assembleur des paires. Sur l hote, seules les + # versions de reference et les paires a asm x86-64 tournent. + proj3_add_embedded_executable(proj3_oracle_target + test/oracle/oracle.cpp + test/oracle/main.cpp + test/oracle/pairs_demo.cpp + test/oracle/pairs_render.cpp) + +# =========================================================================== +# CIBLE HOTE (outillage et tests seulement) +# =========================================================================== +else() + + # -- Bibliotheque portable, compilee en mode hote -------------------------- + add_library(proj3_portable STATIC + ${proj3_portable_sources} + src/proj3/sys/panic_host.cpp + src/proj3/mem/page_source_host.cpp + ) + target_include_directories(proj3_portable PUBLIC src) + target_compile_options(proj3_portable PRIVATE ${proj3_common_flags}) + target_compile_definitions(proj3_portable PUBLIC PROJ3_EMBEDDED=0) + + # -- Garde-fou d allocation, en bibliotheque separee ----------------------- + # Separee parce qu il TUE le processus : on ne le lie que dans les + # executables qui pretendent ne rien allouer. + add_library(proj3_newguard STATIC src/proj3/mem/new_guard.cpp) + target_include_directories(proj3_newguard PUBLIC src) + target_compile_options(proj3_newguard PRIVATE ${proj3_common_flags}) + + enable_testing() + + # -- Harnais d oracle ------------------------------------------------------ + add_executable(proj3_oracle + test/oracle/oracle.cpp + test/oracle/main.cpp + test/oracle/pairs_demo.cpp + test/oracle/pairs_render.cpp + asm/host/demo_fill_x86_64.S + ) + target_link_libraries(proj3_oracle PRIVATE proj3_portable proj3_newguard) + target_compile_options(proj3_oracle PRIVATE $<$:${proj3_common_flags}>) + add_test(NAME oracle COMMAND proj3_oracle) + + # -- Preuve que le harnais rejette une implementation fausse --------------- + add_executable(proj3_oracle_selftest + test/oracle/oracle.cpp + test/oracle/selftest_main.cpp + test/oracle/pairs_demo.cpp + asm/host/demo_fill_x86_64.S + ) + target_link_libraries(proj3_oracle_selftest PRIVATE proj3_portable) + target_compile_options(proj3_oracle_selftest PRIVATE $<$:${proj3_common_flags}>) + add_test(NAME oracle_selftest COMMAND proj3_oracle_selftest) + + # -- Tests d arene --------------------------------------------------------- + add_executable(proj3_test_arena test/test_arena.cpp) + target_link_libraries(proj3_test_arena PRIVATE proj3_portable proj3_newguard) + target_compile_options(proj3_test_arena PRIVATE ${proj3_common_flags}) + add_test(NAME arena COMMAND proj3_test_arena) + + # -- Test du garde-fou : DOIT planter ------------------------------------- + add_executable(proj3_test_newguard test/test_new_guard.cpp) + target_link_libraries(proj3_test_newguard PRIVATE proj3_portable proj3_newguard) + target_compile_options(proj3_test_newguard PRIVATE ${proj3_common_flags}) + add_test(NAME new_guard_traps COMMAND proj3_test_newguard) + set_tests_properties(new_guard_traps PROPERTIES WILL_FAIL TRUE) + + # -- Test de portage du rasterizer (golden) -------------------------------- + add_executable(proj3_test_raster test/test_raster_golden.cpp) + target_link_libraries(proj3_test_raster PRIVATE proj3_portable proj3_newguard) + target_compile_options(proj3_test_raster PRIVATE ${proj3_common_flags}) + add_test(NAME raster_golden COMMAND proj3_test_raster + "${CMAKE_CURRENT_SOURCE_DIR}/test/data/Inter-Regular.ttf" + "${CMAKE_CURRENT_SOURCE_DIR}/test/data/golden_write.txt") + + # -- Generateur de references depuis Gastinel Write ------------------------ + # Compile les sources ORIGINALES de Write (ttf.cpp + rasterizer.cpp, qui ne + # dependent d aucune API Windows) pour produire l oracle externe du portage. + # Optionnel : n existe que si -DPROJ3_WRITE_SRC= est fourni. + if(PROJ3_WRITE_SRC) + add_executable(proj3_write_reference + tools/write_reference_dump.cpp + "${PROJ3_WRITE_SRC}/font/ttf.cpp" + "${PROJ3_WRITE_SRC}/render/rasterizer.cpp") + target_include_directories(proj3_write_reference PRIVATE "${PROJ3_WRITE_SRC}") + target_compile_features(proj3_write_reference PRIVATE cxx_std_20) + endif() + +endif() diff --git a/README.md b/README.md new file mode 100644 index 0000000..e370bf9 --- /dev/null +++ b/README.md @@ -0,0 +1,200 @@ +# proj3 + +> **`proj3` est un PLACEHOLDER.** Le nom officiel du projet n est pas arrete. +> Il apparait comme prefixe de namespace, prefixe de symbole assembleur, prefixe +> de macro et nom de cible CMake. La liste exhaustive des endroits a substituer +> est en fin de ce fichier, section « Substitution du nom ». + +Environnement graphique deterministe pour ARM64 (AArch64) sur noyau Linux. +Cible de prototypage : Google Pixel 3a (`sargo`). Cible ulterieure : Poco F5 Pro +(`mondrian`). + +## Les trois piliers + +1. **Determinisme de latence.** Ce qui compte est la variance, pas le debit + moyen. Toute construction a variabilite non bornee est rejetee, meme si elle + est plus rapide en moyenne. +2. **Budget memoire explicite.** Aucune allocation dynamique apres l init. Tout + est prealloue en arenes de taille fixe. +3. **Acces direct justifie.** Chaque couche traversee doit etre justifiee. Pas + de libc, pas de framework, pas de dependance externe. + +## Arborescence + +| dossier | contenu | +|---|---| +| `src/` | code C++ (`src/proj3/` : `base`, `sys`, `mem`, `font`, `render`, `boot`) | +| `asm/` | code assembleur AArch64 (`.S`) ; `asm/host/` contient la seule exception x86-64, expliquee plus bas | +| `doc/` | conventions, decisions (`doc/adr/`), notes de methode | +| `test/` | harnais de test : oracle, arenes, syscalls, portage du rasterizer | +| `tools/` | outillage de developpement (generateur de references depuis Gastinel Write) | +| `cmake/` | fichiers de toolchain de cross-compilation | + +## Documents de reference + +| document | ce qu il fixe | +|---|---| +| [`doc/convention-aarch64.md`](doc/convention-aarch64.md) | AAPCS64, conventions internes, nommage des symboles, regles NEON. Fait autorite sur tout `.S`. | +| [`doc/convention-syscall.md`](doc/convention-syscall.md) | remontee d erreur syscall. **Decision definitive, une seule convention.** | +| [`doc/methode-oracle.md`](doc/methode-oracle.md) | validation croisee C++ / assembleur, comment ajouter une paire | +| [`doc/memoire.md`](doc/memoire.md) | trois modes de pages, cinq arenes, garde-fou d allocation | +| [`doc/adr/`](doc/adr/) | ADR-0001 socle, ADR-0002 wrappers asm, ADR-0003 arenes, ADR-0004 portage | + +## Construction + +### Prerequis Debian / Ubuntu + +```bash +sudo apt install cmake ninja-build +``` + +Puis **au choix**, une des deux familles de toolchain : + +```bash +# Famille 1 (recommandee sous Debian) : GCC croise +sudo apt install g++-aarch64-linux-gnu binutils-aarch64-linux-gnu + +# Famille 2 : Clang/LLVM monolithe (un seul paquet pour toutes les cibles) +sudo apt install clang lld llvm +``` + +Le paquet **`g++-aarch64-linux-gnu`** est celui qui fournit le +cross-compilateur `aarch64-linux-gnu-g++`. Aucun sysroot n est necessaire : le +binaire est `-nostdlib` et n a besoin d aucune bibliotheque cible. + +Pour executer le harnais de syscalls sans materiel ARM : + +```bash +sudo apt install qemu-user +``` + +### Cible embarquee (AArch64, le produit) + +```bash +cmake -S . -B build-arm64 -G Ninja \ + -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-linux.cmake +ninja -C build-arm64 +``` + +La famille de toolchain est choisie automatiquement (GCC croise s il est +present, Clang sinon) et peut etre forcee par `-DPROJ3_TOOLCHAIN=gcc` ou +`-DPROJ3_TOOLCHAIN=clang`. **Aucun chemin n est en dur** : le fichier de +toolchain cherche dans le `PATH`. + +Binaires produits : + +| binaire | role | +|---|---| +| `proj3_boot` | le produit. Acquiert la memoire, journalise le mode de pages, termine avec le code 0. | +| `proj3_test_syscalls` | harnais des wrappers syscall | +| `proj3_oracle_target` | harnais d oracle, versions assembleur AArch64 comprises | + +### Cible hote (outillage et tests) + +```bash +cmake -S . -B build-host -G Ninja +ninja -C build-host +ctest --test-dir build-host --output-on-failure +``` + +### Verifier que le binaire ne depend de rien + +```bash +llvm-readelf -h build-arm64/proj3_boot # Type EXEC, Machine AArch64 +llvm-readelf -d build-arm64/proj3_boot # aucune section .dynamic +llvm-nm -u build-arm64/proj3_boot # aucun symbole indefini +``` + +(ou `readelf` / `nm` prefixes `aarch64-linux-gnu-` avec la toolchain GCC.) + +### Executer le harnais de syscalls + +Sur n importe quel Linux AArch64 — Raspberry Pi 64 bits, VM, conteneur — ou +sous emulation utilisateur. **Pas besoin du telephone.** + +```bash +qemu-aarch64 build-arm64/proj3_test_syscalls ; echo "code=$?" +``` + +## Double cible : une asymetrie assumee + +Il y a **deux cibles, et elles n ont pas les memes droits** : + +- **Cible embarquee** (`aarch64-linux`, freestanding) : le produit. `-nostdlib`, + pas de libc, point d entree `_start` maison, syscalls maison. +- **Cible hote** (la machine de dev) : l outillage seul. **Elle a le droit + d utiliser la libc de l hote.** Elle ne produit jamais de binaire livre. + +La raison est simple : le harnais d oracle doit pouvoir tourner sans telephone, +sans affichage et sans emulateur, sinon il ne sera pas execute. + +La frontiere est materialisee dans `CMakeLists.txt` par la liste +`proj3_portable_sources`. Ces unites sont freestanding par construction et +compilees a l identique par les deux cibles ; ce sont les seules partagees. +Tout le reste est specifique a une cible et **le nom du fichier le dit** : +`page_source_linux.cpp` contre `page_source_host.cpp`, `panic.cpp` contre +`panic_host.cpp`. + +Consequence visible : `asm/host/demo_fill_x86_64.S`. La machine de dev ne peut +pas executer de l AArch64 ; pour que la preuve « le harnais sait rejeter une +implementation fausse » puisse etre faite sur la machine de dev, la paire de +demonstration existe dans les deux jeux d instructions. **Ce doublon ne sera pas +etendu** aux vraies routines : cf. `doc/methode-oracle.md` section 7. + +## Dette technique — inventaire + +Rien de ce qui suit n est implicite. Chaque point est aussi documente a +l endroit du code concerne. + +### Heritee de Gastinel Write, CONSERVEE VOLONTAIREMENT + +| dette | ou | statut | +|---|---|---| +| **Pas de crenage** (ni `kern` ni GPOS) | `font/ttf.hpp` | volontaire cote Write, non corrigee ici | +| **Pas d antialiasing** : couverture binaire 0 ou 255 | `render/rasterizer.hpp` | volontaire cote Write, non corrigee ici | +| **Pas de hinting** : les instructions `fpgm`/`prep`/`cvt` sont ignorees | `font/ttf.hpp` | volontaire cote Write, non corrigee ici | +| Polices CFF / CFF2 / WOFF / TTC refusees | `font/ttf.cpp` | refus explicite avec message utile | +| Alignement composite par indices de points non gere | `font/ttf.cpp` | rarissime hors CJK ancien | + +### Introduite ou heritee du socle + +| dette | ou | pourquoi elle existe | +|---|---|---| +| `clock_gettime` passe par un vrai `svc`, **pas par le vDSO** | `asm/syscall.S` | le vDSO demande de parcourir l auxiliary vector et de resoudre un symbole ELF ; hors perimetre du chantier 2. A traiter au chantier de mesure de latence, la ou ca comptera. | +| `_start` **ne parcourt pas `.init_array`** | `asm/start.S` | le projet n a aucun constructeur statique non trivial. Verifie : `llvm-readelf -S` ne montre aucune section `.init_array` dans `proj3_boot`. Si un jour il en fallait un, l ADR-0001 devrait etre revise. | +| `memcpy` / `memset` / `memmove` / `memcmp` fournis a la main | `base/cstring.cpp` | le compilateur peut les emettre de lui-meme meme en `-ffreestanding`. Implementations naives, octet par octet : ce sont des candidats evidents pour une paire d oracle et un noyau NEON. | +| `std::hypot` remplace par un calcul naif en `double` | `base/math.hpp` | pas de libm. **Seule divergence numerique connue du portage.** Verifiee nulle sur le jeu de test golden (120 combinaisons glyphe/taille). | +| Enregistrement des paires d oracle : deux mecanismes selon la cible | `test/oracle/oracle.hpp` | section ELF `proj3_pairs` sur la cible (pas de `.init_array`), constructeur statique sur l hote (PE ne synthetise pas `__start_`/`__stop_`). | +| Une variable globale mutable : le mode de pages retenu | `mem/page_source_*.cpp` | seule entorse a « pas de `.data` mutable ». Ecrite une fois a l init, lue ensuite. Justifiee dans le fichier. | +| Le harnais d oracle detourne l arene `scanout` pour lire des fichiers | `test/test_raster_golden.cpp` | detournement local a un test, assume. | +| Pas de mesure de latence, pas de DRM/KMS, pas de `/dev/input` | — | hors perimetre : depend de verifications materielles non faites sur le Pixel 3a. | + +## Licence des polices + +`test/data/Inter-Regular.ttf` est distribue avec le depot pour le test de +portage du rasterizer. **Inter est sous SIL Open Font License 1.1** ; le texte +integral de la licence accompagne la police dans `test/data/OFL.txt`, comme +l OFL l exige (clause 2 : la notice de copyright et la licence doivent +accompagner toute redistribution). + +Copyright (c) 2016 The Inter Project Authors — https://github.com/rsms/inter + +## Substitution du nom + +`proj3` doit etre remplace partout ci-dessous quand le vrai nom sera arrete : + +| ou | forme | +|---|---| +| `src/proj3/` | nom du dossier | +| tous les `#include "proj3/..."` | chemin d inclusion | +| `namespace proj3` et ses sous-namespaces | `proj3::sys`, `proj3::mem`, `proj3::font`, `proj3::render`, `proj3::oracle` | +| `asm/*.S` | symboles `proj3_sys_*`, `proj3_fill_bytes_*`, `_start` (inchange) | +| `src/proj3/sys/syscall_nr.hpp` | macros `PROJ3_NR_*`, `PROJ3_AT_FDCWD` | +| `CMakeLists.txt` | `project(proj3)`, cibles `proj3_*`, variables `PROJ3_*` | +| `test/oracle/oracle.hpp` | macro `PROJ3_ORACLE_PAIR`, section ELF `proj3_pairs` | +| `mem/new_guard.cpp`, `sys/panic.cpp` | prefixe des messages `proj3:` | +| ce README et les documents de `doc/` | texte | + +La section ELF `proj3_pairs` est le seul endroit ou le nom a une contrainte +technique : il doit rester un **identifiant C valide**, sans quoi l editeur de +liens ne synthetise plus `__start_` / `__stop_`. diff --git a/asm/demo_fill_aarch64.S b/asm/demo_fill_aarch64.S new file mode 100644 index 0000000..47b4a96 --- /dev/null +++ b/asm/demo_fill_aarch64.S @@ -0,0 +1,74 @@ +// asm/demo_fill_aarch64.S — paire de DEMONSTRATION du harnais d oracle. +// +// Ces routines n ont aucune utilite en production. Elles existent pour prouver +// que le harnais (a) accepte une implementation correcte et (b) rejette une +// implementation fausse dont on connait le defaut. Un harnais qui ne sait pas +// detecter une erreur connue ne vaut rien. +// +// Contrat commun (proj3::oracle::RunFn) : +// x0 = const u8* in +// x1 = usize in_len +// x2 = u8* out +// x3 = usize out_cap +// retour x0 = nombre d octets ecrits +// +// Semantique : si in_len == 0, ne rien ecrire et rendre 0. Sinon remplir +// out_cap octets avec in[0] et rendre out_cap. +// +// Conventions : doc/convention-aarch64.md. Ces deux routines sont des feuilles +// (aucun bl, sp intact). Elles n ecrasent que x4-x6, tous caller-saved. + + .text + .balign 4 + .global proj3_fill_bytes_asm + .hidden proj3_fill_bytes_asm + .type proj3_fill_bytes_asm, %function +proj3_fill_bytes_asm: + cbz x1, .Lfill_bytes_empty + ldrb w4, [x0] // valeur a ecrire + mov x5, #0 // compteur +.Lfill_bytes_loop: + cmp x5, x3 + b.hs .Lfill_bytes_done + strb w4, [x2, x5] + add x5, x5, #1 + b .Lfill_bytes_loop +.Lfill_bytes_done: + mov x0, x3 + ret +.Lfill_bytes_empty: + mov x0, #0 + ret + .size proj3_fill_bytes_asm, . - proj3_fill_bytes_asm + +// --- VERSION VOLONTAIREMENT FAUSSE ---------------------------------------- +// Defaut injecte : un octet de moins que demande, mais la longueur RENDUE est +// correcte. C est exactement le genre de bug qu un test trop indulgent laisse +// passer — la taille est bonne, seul le dernier octet manque. + + .text + .balign 4 + .global proj3_fill_bytes_asm_broken + .hidden proj3_fill_bytes_asm_broken + .type proj3_fill_bytes_asm_broken, %function +proj3_fill_bytes_asm_broken: + cbz x1, .Lfill_broken_empty + ldrb w4, [x0] + mov x5, #0 + subs x6, x3, #1 // <-- LE DEFAUT : out_cap - 1 + b.lo .Lfill_broken_done // out_cap == 0 : rien a ecrire +.Lfill_broken_loop: + cmp x5, x6 + b.hs .Lfill_broken_done + strb w4, [x2, x5] + add x5, x5, #1 + b .Lfill_broken_loop +.Lfill_broken_done: + mov x0, x3 // longueur rendue correcte, contenu faux + ret +.Lfill_broken_empty: + mov x0, #0 + ret + .size proj3_fill_bytes_asm_broken, . - proj3_fill_bytes_asm_broken + + .section .note.GNU-stack,"",@progbits diff --git a/asm/host/demo_fill_x86_64.S b/asm/host/demo_fill_x86_64.S new file mode 100644 index 0000000..c7fdd10 --- /dev/null +++ b/asm/host/demo_fill_x86_64.S @@ -0,0 +1,88 @@ +// asm/host/demo_fill_x86_64.S — la MEME paire de demonstration, en x86-64. +// +// POURQUOI CE FICHIER EXISTE. Le harnais d oracle doit tourner sur la machine +// de developpement, sans telephone et sans emulateur (contrainte de conception +// du chantier 4). Or la machine de dev est x86-64 : elle ne peut pas executer +// proj3_fill_bytes_asm, qui est de l AArch64. +// +// Sans ce fichier, le harnais compare sur l hote la reference C++ a rien du +// tout, et la preuve qu il sait rejeter une erreur ne peut se faire que sur +// la cible. C est exactement l inverse de ce qu on veut. +// +// Ce fichier n existe donc QUE pour la paire de demonstration, et il ne sera +// jamais etendu : les vraies routines optimisees seront ecrites en AArch64 +// seulement, et leur comparaison se fera sur la cible (executable +// proj3_oracle_target). Sur l hote, elles apparaitront comme "reference figee, +// version assembleur absente". C est une limite assumee et documentee dans +// doc/methode-oracle.md. +// +// Contrat identique : (in, in_len, out, out_cap) -> octets ecrits. + + .intel_syntax noprefix + .text + +// Deux ABI possibles. On les ramene a des noms uniformes en tete de routine +// plutot que d ecrire deux fois le corps. +#if defined(_WIN64) || defined(__CYGWIN__) + // ABI Microsoft x64 : rcx, rdx, r8, r9 + #define P3_IN rcx + #define P3_INLEN rdx + #define P3_OUT r8 + #define P3_CAP r9 +#else + // ABI System V AMD64 : rdi, rsi, rdx, rcx + #define P3_IN rdi + #define P3_INLEN rsi + #define P3_OUT rdx + #define P3_CAP rcx +#endif + + .globl proj3_fill_bytes_asm +proj3_fill_bytes_asm: + test P3_INLEN, P3_INLEN + je .Lfill_bytes_empty + movzx eax, byte ptr [P3_IN] + mov r10, P3_OUT + xor r11, r11 +.Lfill_bytes_loop: + cmp r11, P3_CAP + jae .Lfill_bytes_done + mov byte ptr [r10 + r11], al + inc r11 + jmp .Lfill_bytes_loop +.Lfill_bytes_done: + mov rax, P3_CAP + ret +.Lfill_bytes_empty: + xor eax, eax + ret + +// --- VERSION VOLONTAIREMENT FAUSSE : un octet de moins --------------------- + .globl proj3_fill_bytes_asm_broken +proj3_fill_bytes_asm_broken: + test P3_INLEN, P3_INLEN + je .Lfill_broken_empty + movzx eax, byte ptr [P3_IN] + mov r10, P3_OUT + xor r11, r11 + mov rax, P3_CAP + test rax, rax + je .Lfill_broken_done + dec rax // <-- LE DEFAUT : out_cap - 1 + movzx r8d, byte ptr [P3_IN] // (recharge : rax servait de compteur) +.Lfill_broken_loop: + cmp r11, rax + jae .Lfill_broken_done + mov byte ptr [r10 + r11], r8b + inc r11 + jmp .Lfill_broken_loop +.Lfill_broken_done: + mov rax, P3_CAP + ret +.Lfill_broken_empty: + xor eax, eax + ret + +#if defined(__ELF__) + .section .note.GNU-stack,"",@progbits +#endif diff --git a/asm/start.S b/asm/start.S new file mode 100644 index 0000000..17dad2a --- /dev/null +++ b/asm/start.S @@ -0,0 +1,54 @@ +// asm/start.S — point d entree du processus, sans crt1.o ni libc. +// +// Conventions : doc/convention-aarch64.md. +// +// Etat a l entree, garanti par le noyau (fs/binfmt_elf.c, ELF ABI AArch64) : +// sp -> argc, puis argv[0..argc-1], NULL, envp[...], NULL, auxv[...] +// x0 -> 0 (Linux ne passe rien ; c est l ABI System V generique qui +// prevoit un pointeur de fonction atexit, toujours nul sous Linux) +// Tous les autres registres generaux sont indefinis. Ne rien supposer. +// sp est deja aligne sur 16 octets. +// +// Ce que ce fichier NE fait PAS, et pourquoi : +// - il ne parcourt pas .init_array : le projet n a aucun constructeur +// statique non trivial (cf. ADR-0001). Si un jour il en fallait un, c est +// ici qu il faudrait le traiter, et l ADR devrait etre revise. +// - il ne met pas en place de TLS : pas de thread, pas de thread_local. +// - il ne retourne jamais. proj3_main est appele, sa valeur de retour part +// directement dans exit_group. + + .text + .balign 4 + .global _start + .hidden _start + .type _start, %function +_start: + // Le cadre de pile initial n a pas d appelant : on ancre le pointeur de + // trame a zero pour qu un derouleur de pile (debogueur, perf) s arrete ici + // proprement au lieu de suivre des ordures. + mov x29, xzr + mov x30, xzr + + // argc et argv, pour proj3_main(int argc, char** argv). + // argc est un mot de 64 bits sur la pile ; on ne garde que 32 bits utiles. + ldr x0, [sp] // argc + add x1, sp, #8 // argv + + // sp est deja aligne sur 16 ; on ne le modifie pas, donc l alignement + // requis a la frontiere d appel est trivialement respecte. + bl proj3_main + + // Valeur de retour de proj3_main dans w0 -> code de sortie. + // exit_group (94) et non exit (93) : on veut terminer le processus entier, + // pas seulement le fil courant. La distinction est sans objet aujourd hui + // (mono-fil) mais le jour ou elle en aura une, ce sera silencieusement. + and x0, x0, #0xff + mov x8, #94 // __NR_exit_group + svc #0 + + // Inatteignable. Si le noyau revenait malgre tout, on piege plutot que de + // continuer dans du code indefini. + brk #0 + .size _start, . - _start + + .section .note.GNU-stack,"",@progbits diff --git a/asm/syscall.S b/asm/syscall.S new file mode 100644 index 0000000..092f341 --- /dev/null +++ b/asm/syscall.S @@ -0,0 +1,143 @@ +// asm/syscall.S — wrappers d appels systeme AArch64, assembleur pur. +// +// Conventions : doc/convention-aarch64.md et doc/convention-syscall.md. +// +// FORME CANONIQUE, et pourquoi elle est aussi courte : +// +// proj3_sys_: +// mov x8, #PROJ3_NR_ +// svc #0 +// ret +// +// L ABI syscall Linux/AArch64 (arch/arm64/kernel/entry.S, et Documentation/ +// arm64/) fait coincider exactement les registres d arguments de l AAPCS64 et +// ceux de l appel systeme : +// +// argument 1..6 -> x0 x1 x2 x3 x4 x5 +// numero d appel -> x8 +// retour -> x0 +// +// Il n y a donc AUCUN mouvement de registre a faire dans le cas general. Le +// 6e argument de mmap arrive en x5 par l ABI d appel normale : rien de special +// n est requis, contrairement a x86-64 ou r10 remplace rcx. +// +// Registres detruits par svc : x0 (resultat) et x8 (que nous avons ecrit). +// Le noyau preserve x1-x7 et x9-x30. x8 etant caller-saved en AAPCS64, nous +// avons le droit de l ecraser sans le sauvegarder. +// +// ALIGNEMENT DE PILE : aucun de ces wrappers ne touche a sp ni n empile x30. +// L alignement 16 octets exige par l AAPCS64 est donc preserve trivialement, +// par construction et non par vigilance. +// +// LA VALEUR DE RETOUR N EST PAS TRANSFORMEE. Le x0 du noyau ressort tel quel, +// conformement a l option C de doc/convention-syscall.md. Le test de plage +// [-4095, -1] est fait cote C++ par proj3::sys::Result::is_err(), en constexpr +// inline, et seulement quand l appelant le demande. + +#include "proj3/sys/syscall_nr.hpp" + +// Macro d emission d un wrapper direct (aucun remaniement d argument). +// L usage d une macro ici n est pas de la coquetterie : il garantit que les +// 14 wrappers directs sont rigoureusement identiques, donc qu aucun d entre +// eux ne peut avoir un prologue ou une transformation qui traine. +.macro PROJ3_SYSCALL_DIRECT name, nr + .text + .balign 4 + .global proj3_sys_\name + .hidden proj3_sys_\name + .type proj3_sys_\name, %function +proj3_sys_\name: + mov x8, #\nr + svc #0 + ret + .size proj3_sys_\name, . - proj3_sys_\name +.endm + +// --- Fichiers ------------------------------------------------------------- + + // open : la table generique AArch64 n a PAS de __NR_open. On passe par + // openat avec AT_FDCWD. C est le seul wrapper qui remanie ses arguments, + // et c est la raison pour laquelle il n utilise pas la macro. + // + // entree : x0 = const char* path + // x1 = int flags + // x2 = int mode (ignore par le noyau sans O_CREAT) + // sortie : x0 = fd ou -errno + .text + .balign 4 + .global proj3_sys_open + .hidden proj3_sys_open + .type proj3_sys_open, %function +proj3_sys_open: + mov x3, x2 // mode -> arg4 + mov x2, x1 // flags -> arg3 + mov x1, x0 // path -> arg2 + mov x0, #PROJ3_AT_FDCWD // dirfd -> arg1 + mov x8, #PROJ3_NR_openat + svc #0 + ret + .size proj3_sys_open, . - proj3_sys_open + +PROJ3_SYSCALL_DIRECT close, PROJ3_NR_close +PROJ3_SYSCALL_DIRECT read, PROJ3_NR_read +PROJ3_SYSCALL_DIRECT write, PROJ3_NR_write +PROJ3_SYSCALL_DIRECT ioctl, PROJ3_NR_ioctl +PROJ3_SYSCALL_DIRECT fstat, PROJ3_NR_fstat +PROJ3_SYSCALL_DIRECT lseek, PROJ3_NR_lseek + +// --- Memoire -------------------------------------------------------------- +// +// mmap prend six arguments : addr, length, prot, flags, fd, offset. +// Le sixieme (offset) arrive en x5 par l AAPCS64 et c est exactement la ou le +// noyau l attend. Verifie sur arch/arm64 : le point d entree svc recopie +// x0-x5 dans les six premiers champs de pt_regs, sans decalage. +// C est la difference avec x86-64, ou l argument 4 doit etre deplace de rcx +// vers r10 parce que syscall ecrase rcx. + +PROJ3_SYSCALL_DIRECT mmap, PROJ3_NR_mmap +PROJ3_SYSCALL_DIRECT munmap, PROJ3_NR_munmap +PROJ3_SYSCALL_DIRECT madvise, PROJ3_NR_madvise + +// --- Temps ---------------------------------------------------------------- +// +// Note d honnetete : clock_gettime passe ici par un vrai svc, PAS par le +// vDSO. Le vDSO eviterait la transition en mode noyau et couterait environ +// vingt fois moins cher. Ce n est pas un oubli : utiliser le vDSO demande de +// parcourir l auxiliary vector (AT_SYSINFO_EHDR) et de resoudre un symbole +// ELF au demarrage, ce qui n est pas dans le perimetre du chantier 2. Dette +// documentee, a traiter au chantier de mesure de latence — la ou elle +// comptera vraiment. + +PROJ3_SYSCALL_DIRECT clock_gettime, PROJ3_NR_clock_gettime +PROJ3_SYSCALL_DIRECT nanosleep, PROJ3_NR_nanosleep + +// --- Processus ------------------------------------------------------------ + +PROJ3_SYSCALL_DIRECT getpid, PROJ3_NR_getpid + + // exit et exit_group ne reviennent pas. Le `ret` de la macro serait mort ; + // on met un brk a la place pour que, si le noyau revenait (il ne le fait + // pas), on s arrete net au lieu de partir dans du code indefini. + .text + .balign 4 + .global proj3_sys_exit + .hidden proj3_sys_exit + .type proj3_sys_exit, %function +proj3_sys_exit: + mov x8, #PROJ3_NR_exit + svc #0 + brk #0 + .size proj3_sys_exit, . - proj3_sys_exit + + .text + .balign 4 + .global proj3_sys_exit_group + .hidden proj3_sys_exit_group + .type proj3_sys_exit_group, %function +proj3_sys_exit_group: + mov x8, #PROJ3_NR_exit_group + svc #0 + brk #0 + .size proj3_sys_exit_group, . - proj3_sys_exit_group + + .section .note.GNU-stack,"",@progbits diff --git a/cmake/toolchain-aarch64-linux.cmake b/cmake/toolchain-aarch64-linux.cmake new file mode 100644 index 0000000..c9222e1 --- /dev/null +++ b/cmake/toolchain-aarch64-linux.cmake @@ -0,0 +1,51 @@ +# cmake/toolchain-aarch64-linux.cmake — cible finale : AArch64 / Linux, freestanding. +# +# AUCUN chemin en dur ici. Les binaires sont cherches dans le PATH, ou +# surcharges par l appelant via -DPROJ3_AARCH64_CC=... / -DPROJ3_AARCH64_CXX=... +# +# Deux familles de toolchain sont acceptees : +# 1. GCC croise Debian : aarch64-linux-gnu-gcc / -g++ (paquet g++-aarch64-linux-gnu) +# 2. Clang/LLVM monolithe : clang / clang++ -target aarch64-linux-gnu + ld.lld +# +# La famille est choisie par -DPROJ3_TOOLCHAIN=gcc|clang (defaut : gcc si +# aarch64-linux-gnu-g++ existe, clang sinon). + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR aarch64) + +# Rien a lier : pas de libc, pas de sysroot. On empeche CMake de tenter un +# link de test qui echouerait faute de crt*.o. +set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + +if(NOT DEFINED PROJ3_TOOLCHAIN) + find_program(_p3_gcc aarch64-linux-gnu-g++) + if(_p3_gcc) + set(PROJ3_TOOLCHAIN "gcc") + else() + set(PROJ3_TOOLCHAIN "clang") + endif() +endif() + +if(PROJ3_TOOLCHAIN STREQUAL "gcc") + set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc) + set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++) + set(CMAKE_ASM_COMPILER aarch64-linux-gnu-gcc) + set(PROJ3_TARGET_TRIPLE_FLAGS "") + set(PROJ3_LINK_DRIVER_FLAGS "") +else() + set(CMAKE_C_COMPILER clang) + set(CMAKE_CXX_COMPILER clang) + set(CMAKE_ASM_COMPILER clang) + # clang++ n est pas utilise : on invoque clang avec -x c++ via CMake, ce qui + # evite qu il tente de lier libc++ implicitement. + set(CMAKE_CXX_COMPILER clang++) + set(PROJ3_TARGET_TRIPLE_FLAGS "--target=aarch64-linux-gnu") + set(PROJ3_LINK_DRIVER_FLAGS "-fuse-ld=lld") +endif() + +set(PROJ3_TARGET_TRIPLE_FLAGS "${PROJ3_TARGET_TRIPLE_FLAGS}" CACHE INTERNAL "") +set(PROJ3_LINK_DRIVER_FLAGS "${PROJ3_LINK_DRIVER_FLAGS}" CACHE INTERNAL "") + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BEFORE) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/doc/adr/ADR-0001-socle-compilation.md b/doc/adr/ADR-0001-socle-compilation.md new file mode 100644 index 0000000..41e1f26 --- /dev/null +++ b/doc/adr/ADR-0001-socle-compilation.md @@ -0,0 +1,109 @@ +# ADR-0001 — Socle de compilation : C++20 bride, absence de libc, double cible + +- Statut : accepte +- Date : 2026-09-05 +- Portee : chantier 1 (structure du depot, chaine de compilation) + +## Contexte + +Le projet vise un environnement graphique deterministe sur AArch64/Linux, avec +trois piliers : determinisme de latence, budget memoire explicite, acces direct +justifie. Aucune ligne de code fonctionnel n existe encore. Il faut fixer le +socle avant d ecrire quoi que ce soit, sinon les choix se prendront par defaut +et par accident. + +## Decision + +### 1. C++20, bride + +Compile avec `-std=c++20 -nostdlib -fno-exceptions -fno-rtti +-fno-threadsafe-statics -Wall -Wextra -O2`. + +- `-fno-exceptions` : une exception est un chemin de sortie de latence non + bornee (deroulement de pile, tables `.eh_frame`, allocation du bloc + d exception). Incompatible avec le pilier 1. +- `-fno-rtti` : `dynamic_cast` et `typeid` impliquent une comparaison de + chaines ou une marche de hierarchie a l execution. Le projet n a aucun + polymorphisme dynamique prevu. +- `-fno-threadsafe-statics` : sans cette option, chaque variable statique + locale non triviale genere un appel a `__cxa_guard_acquire` — donc une + dependance libc et un branchement supplementaire a chaque acces. Le projet + n a pas d initialisation statique dynamique (cf. ADR-0003 sur les arenes). +- `-O2` et non `-O3` : `-O3` active un deroulage et une vectorisation + agressifs dont le gain est incertain et le cout en taille de code (donc en + pression sur le cache d instructions, donc en variance) est reel. Le projet + optimisera par des noyaux assembleur explicites, pas par des drapeaux. +- `-Wall -Wextra` avec zero warning tolere. Aucun `-Werror` en local pour ne + pas bloquer un debogage, mais la regle est contractuelle. + +Ce qui reste autorise du C++ : `constexpr`, templates, `` et les +autres en-tetes purement compile-time. Aucun conteneur, aucun `std::string`, +aucun flux. + +### 2. Aucune libc, point d entree maison + +Le binaire final est lie avec `-nostdlib -nostartfiles -static -Wl,-e,_start`. +`_start` est ecrit en assembleur (`asm/start.S`), appelle une fonction C++ +unique, puis termine le processus par `exit_group` via `svc #0`. + +Raison : le pilier 3. Une libc apporte un initialiseur (`__libc_start_main`), +un allocateur (`malloc`), des tampons de flux, des gestionnaires TLS et une +resolution de symboles dynamique — toutes choses dont le projet ne veut ni le +comportement memoire ni la variance. Le cout assume est qu il faut ecrire +soi-meme tout ce dont on a besoin : les wrappers syscall (chantier 2), les +routines memoire, les conversions numeriques. + +Consequence non evidente, notee ici pour memoire : sans `crt1.o`, il n y a +**aucun appel aux constructeurs statiques** (`.init_array`). Le projet ne doit +donc dependre d aucune initialisation statique non triviale, ou bien +`_start` devra parcourir `.init_array` explicitement. Le choix actuel est le +premier : pas d initialisation statique dynamique du tout. + +### 3. Double cible, asymetrique + +- **Cible embarquee** `aarch64-linux`, freestanding : le produit. +- **Cible hote**, la machine de developpement : l outillage seul (harnais + d oracle du chantier 4, generateurs de references). + +**La cible hote a le droit d utiliser la libc de l hote.** Elle ne produit +jamais de binaire livre. Cette asymetrie est deliberee : le harnais doit +pouvoir s executer sans telephone, sans affichage et sans emulateur, sinon il +ne sera pas execute. + +La frontiere est materialisee dans `CMakeLists.txt` par la liste +`proj3_portable_sources`. Ces unites de compilation sont freestanding par +construction et compilees a l identique par les deux cibles ; ce sont les +seules partagees. Tout le reste est specifique a une cible et le nom du +fichier le dit (`page_source_linux.cpp` / `page_source_host.cpp`). + +Risque accepte et surveille : une divergence de comportement flottant ou +d endianness entre hote x86-64 et cible AArch64 rendrait la comparaison du +harnais trompeuse. Les hypotheses correspondantes sont listees dans +`doc/methode-oracle.md` (mode d arrondi IEEE identique, little-endian des deux +cotes, pas de x87 80 bits car x86-64 utilise SSE2 pour `float`/`double`). + +## Alternatives ecartees + +- **Utiliser une libc minimale (musl, picolibc).** Aurait fait gagner du temps + au demarrage. Ecartee : elle reintroduit `malloc` et un initialiseur qu il + faudrait ensuite neutraliser un par un, et elle brouille la frontiere que + l ADR cherche precisement a etablir. +- **Cible unique aarch64, tests sous qemu-user.** Ecartee : ajoute une + dependance d emulation au chemin de test le plus frequent. Le harnais doit + etre trivial a lancer, sinon il pourrit. +- **Meson ou Makefile a la main.** Ecarte : CMake+Ninja donne la + cross-compilation par fichier de toolchain et un graphe de dependances + correct sans travail supplementaire. Aucun besoin exotique ici. + +## Consequences + +- Il faut ecrire des wrappers syscall avant tout code utile (chantier 2). +- Il faut ecrire un allocateur avant tout code de rendu (chantier 3). +- Toute tentation d appeler `memcpy` doit etre traitee : `-ffreestanding` + autorise le compilateur a **generer** des appels a `memcpy`/`memset`/ + `memmove`/`memcmp` meme sans libc. Le projet doit fournir ces quatre + symboles lui-meme. C est note comme dette a traiter au moment ou un lien + echoue dessus ; a ce jour aucun appel n a ete genere (verifie par + `llvm-nm -u` sur le binaire, qui ne liste aucun symbole indefini). +- L absence de `-Werror` repose sur la discipline. Si elle se relache, on + l ajoutera. diff --git a/doc/adr/ADR-0002-wrappers-syscall-en-asm.md b/doc/adr/ADR-0002-wrappers-syscall-en-asm.md new file mode 100644 index 0000000..1a14f61 --- /dev/null +++ b/doc/adr/ADR-0002-wrappers-syscall-en-asm.md @@ -0,0 +1,84 @@ +# ADR-0002 — Wrappers syscall en assembleur plutot qu en asm inline C++ + +- Statut : accepte +- Date : 2026-09-05 +- Portee : chantier 2 + +## Contexte + +Sans libc, il faut emettre `svc #0` soi-meme. Deux facons de le faire : + +1. **Assembleur pur**, dans un `.S` : une routine par appel, assemblee telle + quelle, appelee par `bl`. +2. **Assembleur inline** dans une fonction C++ `static inline`, avec des + contraintes de registres et une liste de clobbers. + +L asm inline est la solution la plus repandue — c est ce que fait musl, et ce +que font la plupart des noyaux unikernel. Elle merite donc une justification +explicite d etre ecartee. + +## Decision + +**Assembleur pur, dans `asm/syscall.S`.** + +## Ce que ca coute + +- **Un appel de fonction par syscall.** L asm inline se serait fondu dans + l appelant : pas de `bl`, pas de `ret`, et le compilateur aurait pu ordonner + les instructions autour du `svc`. On paie donc environ deux instructions et + une prediction de branchement par appel. Sur un `svc` qui coute plusieurs + centaines de cycles de transition en mode noyau, c est du bruit — mais c est + un cout reel, et il faut le nommer. +- **Aucune propagation de constantes a travers le wrapper.** Le compilateur ne + voit qu un appel opaque : il ne peut pas savoir que `sys::write(2, s, n)` + utilise toujours le meme descripteur, ni eliminer un appel mort. +- **Deux endroits a tenir a jour** pour ajouter un appel : le `.S` et le `.hpp`. + +## Ce que ca apporte + +1. **Le contrat de registres est verifiable a l oeil.** Une routine de trois + instructions est lisible dans un desassemblage et se compare directement a + `arch/arm64/kernel/entry.S`. Une contrainte inline `"r"(x)` avec une liste + de clobbers est un contrat entre nous et l optimiseur, et ce contrat est + silencieux quand il est faux. +2. **Pas de dependance au comportement de l optimiseur.** L asm inline peut + etre duplique, deplace, ou sorti d une boucle par le compilateur s il juge + le bloc pur. Il faut alors `volatile` et une liste de clobbers `"memory"` + exacte, sous peine de bugs qui n apparaissent qu a `-O2` et pas a `-O0`. + C est exactement le genre de non-determinisme que le pilier 1 rejette. +3. **Cout constant, mesurable, identique a chaque site d appel.** Avec l asm + inline, le code genere autour du `svc` depend du contexte : le cout du + wrapper varie d un appel a l autre. Ici il est le meme partout. +4. **Alignement de pile garanti par construction.** Aucun wrapper ne touche a + `sp` ni n empile `x30`. Il n y a donc rien a verifier : la contrainte des + 16 octets de l AAPCS64 est respectee parce qu il n existe pas de code pour + la violer. +5. **Une macro assure l uniformite.** `PROJ3_SYSCALL_DIRECT` emet les quatorze + wrappers directs a l identique. Il est structurellement impossible que l un + d eux ait un prologue ou une transformation qui traine. + +## Consequences + +- Les numeros d appel sont dans `src/proj3/sys/syscall_nr.hpp`, inclus par le + `.S` (qui est preprocesse). Ils ne sont jamais ecrits en dur dans le corps + d une routine. +- La valeur de retour n est pas transformee dans le wrapper (cf. + `doc/convention-syscall.md`, option C). Le `.S` se limite a + `mov x8, #N` puis `svc #0` puis `ret`. +- `open` est le seul wrapper qui remanie ses arguments : la table generique + AArch64 n a pas de `__NR_open`, seulement `openat`. Il decale les quatre + arguments et injecte `AT_FDCWD`. C est documente dans le fichier, et c est + pour cela qu il n utilise pas la macro. +- Si un jour le cout de l appel devenait mesurable sur un chemin chaud — ce qui + demanderait un syscall dans une boucle serree, situation que le projet + cherche a eviter par ailleurs — la reponse serait de supprimer le syscall, + pas de l inliner. + +## Alternatives ecartees + +- **`asm volatile` inline avec contraintes.** Ecartee pour les raisons 1, 2 et + 3 ci-dessus. +- **Une seule routine generique `syscall(nr, a, b, c, d, e, f)`.** Ecartee : + elle oblige a decaler sept arguments a chaque appel, elle perd le typage des + arguments, et elle rend le desassemblage illisible (tous les appels se + ressemblent). diff --git a/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md b/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md new file mode 100644 index 0000000..f41509b --- /dev/null +++ b/doc/adr/ADR-0003-arene-plutot-qu-allocateur-general.md @@ -0,0 +1,93 @@ +# ADR-0003 — Arene lineaire plutot qu allocateur generaliste + +- Statut : accepte +- Date : 2026-09-05 +- Portee : chantier 3 + +## Contexte + +Le projet doit fournir de la memoire au rasterizer, a l atlas de glyphes, au +scanout et aux tampons d entree. La solution reflexe serait un allocateur +generaliste — un `malloc` maison : listes libres par classe de taille, ou +allocateur de dalles. + +## Decision + +**Un allocateur d arene lineaire (bump allocator), sans liberation +individuelle, sur des arenes de taille fixe decidees a la compilation.** + +## Justification par les piliers + +### Pilier 1 — determinisme de latence + +Un allocateur generaliste a un cout d allocation **variable et non borne** : il +depend de l etat de fragmentation, donc de tout l historique du programme. Deux +executions identiques n ont pas la meme latence. Pire, le cout du pire cas +(fusion de blocs adjacents, parcours d une liste libre longue) arrive rarement +— donc au plus mauvais moment, et de facon irreproductible. + +Une arene alloue en **une addition et un masque**. Le cout est constant, connu, +et identique a la millionieme allocation comme a la premiere. Il n y a pas de +fragmentation parce qu il n y a pas de trous. + +### Pilier 2 — budget memoire explicite + +Un allocateur generaliste rend la question « combien ce programme +consomme-t-il ? » difficile a repondre : le pic depend de l ordre des +allocations. Avec des arenes de taille `constexpr`, la reponse est dans +`mem/layout.hpp` et elle est verifiee a la compilation. + +Surtout : un allocateur generaliste **peut echouer tard**. Une arene, elle, +echoue **fort et tout de suite**, avec le nom de l arene et le calcul a +corriger. + +### Pilier 3 — acces direct justifie + +Un allocateur generaliste est une couche d abstraction de plusieurs centaines +de lignes, avec ses propres invariants et ses propres bugs. Une arene, c est un +pointeur et une capacite. Il n y a rien a justifier parce qu il n y a presque +rien. + +## Ce que ca coute — honnetement + +1. **Aucune liberation individuelle.** Un objet a duree de vie courte au milieu + d objets a duree de vie longue occupe sa place jusqu au prochain `reset()` + de son arene. Il faut donc **penser les durees de vie par lot**, et c est + une discipline reelle : elle se voit dans la conception, pas seulement dans + l implementation. +2. **Le decoupage doit etre juste.** Cinq arenes signifient cinq calculs qui + peuvent etre faux. Un allocateur generaliste aurait absorbe un mauvais + dimensionnement au prix de la latence. Ici, un mauvais dimensionnement + plante. C est voulu : `Arena::peak()` existe pour confronter le calcul a la + realite. +3. **Pas de reutilisation entre arenes.** Si l atlas est plein alors que la + geometrie est vide, on ne peut pas emprunter. Une arene unique partagee + eviterait cela, mais rendrait toute analyse d occupation impossible. On + prefere savoir. +4. **`mark()` / `rewind_to()` est un couteau.** Rembobiner invalide tout ce qui + a ete alloue apres la marque, sans que rien ne le signale. Un pointeur garde + au-dela d un rewind est un usage-apres-liberation classique. Le projet + confine ce motif au harnais et au rasterizer, ou la portee est locale et + visible en entier. + +## Alternatives ecartees + +- **Allocateur de dalles (slab) par type.** Aurait donne un cout constant lui + aussi, et permis la liberation individuelle. Ecarte : il faut une liste libre + par type, donc de l etat mutable par type, et le dimensionnement de chaque + dalle pose exactement le meme probleme que celui des arenes — avec plus de + code. +- **Allocateur de pile unique pour tout le programme.** C est une arene, avec + une seule arene. Ecarte parce qu on perd la ventilation par usage, donc la + capacite de dire quelle partie du programme consomme quoi. +- **Un vrai `malloc`.** Ecarte : cf. pilier 1. + +## Consequences + +- Le rasterizer porte de Gastinel Write ne peut plus faire croitre un + `std::vector` d aretes : il a un plafond (`kMaxEdges`) et un depassement est + un echec explicite. C est un changement de comportement par rapport a + l original, documente dans `render/rasterizer.hpp`. +- Le garde-fou `operator new` (cf. `doc/memoire.md`) est le complement + indispensable de cette decision : sans lui, une allocation cachee + reintroduirait par la fenetre ce que l arene interdit par la porte. diff --git a/doc/adr/ADR-0004-portage-rasterizer.md b/doc/adr/ADR-0004-portage-rasterizer.md new file mode 100644 index 0000000..1e27aee --- /dev/null +++ b/doc/adr/ADR-0004-portage-rasterizer.md @@ -0,0 +1,92 @@ +# ADR-0004 — Portage du rasterizer de Gastinel Write + +- Statut : accepte +- Date : 2026-09-05 +- Portee : chantier 5 + +## Contexte + +Gastinel Write contient un parser TTF maison et un rasterizer scanline nonzero +winding, valides glyphe par glyphe sur Windows. Les reecrire serait du travail +perdu et introduirait des bugs dans du code qui n en a plus. + +## Decision + +**On porte, on ne reecrit pas.** L algorithme est conserve pas a pas ; ce qui +change est l environnement, pas le calcul. + +Changements effectues, et rien d autre : + +| ce qui change | pourquoi | ou | +|---|---|---| +| `std::vector` / `std::string` vers arenes | pilier 2 ; le garde-fou tuerait le processus sinon | partout | +| lecture de fichier retiree de `TtfFont` | `fopen` est de la libc ; l appelant fournit un tampon | `font/ttf.hpp` | +| `std::sort` vers heapsort maison | cout pire cas borne (pilier 1) | `base/sort.hpp` | +| `std::hypot` vers calcul naif en `double` | pas de libm | `base/math.hpp` | +| `std::floor` / `ceil` / `lround` vers equivalents maison | pas de libm | `base/math.hpp` | +| composition separee de la rasterization | rend les noyaux NEON possibles | `render/compose.hpp` | +| plafond d aretes au lieu d un vector qui pousse | une allocation en plein rendu est interdite | `render/rasterizer.hpp` | + +## La separation couverture / composition + +C est le seul changement de **structure**, et il est delibere. + +Dans Write, la rasterization et l ecriture dans le DIB Win32 etaient voisines, +et le format BGRA du DIB s etait infiltre dans le raisonnement. Ici : + +- `render/rasterizer.cpp` produit de la **couverture** : une valeur par pixel, + aucune notion de couleur ni de format ; +- `render/compose.cpp` — et lui seul — connait le format de destination + (XRGB8888, celui d un plan DRM). + +Sans cette separation, un futur noyau NEON de composition obligerait a toucher +au rasterizer, donc a invalider sa validation. + +## La dette technique heritee est CONSERVEE + +Le rasterizer de Write assume explicitement : **pas de crenage, pas +d antialiasing (couverture binaire), pas de hinting**. Ces choix sont +documentes et volontaires cote Write. + +**Ils ne sont pas corriges dans ce chantier.** L avis du portage figure dans le +rapport de chantier, pas dans le code, et aucun de ces trois points n a ete +modifie. + +## Hypotheses qui changent en quittant x86 Windows + +- **Endianness.** Le format TrueType est big-endian et le parser le lit octet + par octet : il est insensible a l endianness de la machine, hier comme + aujourd hui. En revanche la **composition** manipule des `u32` de pixel et + suppose le little-endian ; l hypothese est verifiee par `static_assert` sur + `__BYTE_ORDER__` dans `base/types.hpp` et rappelee dans `render/compose.hpp`. +- **Alignement.** x86-64 tolere les acces desalignes ; AArch64 les tolere pour + les acces ordinaires mais **pas** pour ceux qui utilisent `sp` comme base, et + les futurs noyaux NEON auront des chemins distincts selon l alignement. + `compose_coverage` verifie donc explicitement l alignement 4 octets du + framebuffer au lieu de le supposer. +- **Pile.** Le code d origine allouait des tableaux temporaires par `vector`. + Le portage ne les a pas transformes en tableaux de pile : `GlyphBuilder` + porte les tampons de travail (points, drapeaux, fins de contours) dans une + arene, parce qu une pile sans libc n a pas de page de garde automatique. + +## Verification + +Le portage n est pas « plausible », il est **verifie** : +`tools/write_reference_dump.cpp` compile les sources **originales** de Write +(`font/ttf.cpp` et `render/rasterizer.cpp`, qui ne dependent d aucune API +Windows) et vide leurs sorties dans un format texte. +`test/test_raster_golden.cpp` compare, octet par octet, la sortie du code porte +a cette reference. + +C est ce qui transforme la divergence potentielle de `std::hypot` d un risque +en un fait mesure. + +## Alternatives ecartees + +- **Reecrire depuis la specification TrueType.** Ecarte : c est refaire le + travail de validation glyphe par glyphe deja fait. +- **Garder `std::vector` et n interdire l allocation qu apres l init.** Ecarte : + la frontiere « apres l init » n est pas verifiable mecaniquement, alors que + « jamais » l est, par le garde-fou. +- **Porter aussi la composition telle quelle depuis le backend GDI.** Ecarte : + cf. la separation ci-dessus. diff --git a/doc/convention-aarch64.md b/doc/convention-aarch64.md new file mode 100644 index 0000000..46d2779 --- /dev/null +++ b/doc/convention-aarch64.md @@ -0,0 +1,200 @@ +# Convention de registres AArch64 — reference normative du projet + +Ce document fait autorite sur tout fichier `.S` du depot. Toute routine +assembleur qui s en ecarte doit le declarer en commentaire d en-tete, avec la +raison. + +Cible : AArch64 (ARMv8-A, A64 uniquement, pas de Thumb, pas d AArch32), +Linux, ABI LP64. + +--- + +## 1. Rappel AAPCS64 (Procedure Call Standard for the Arm 64-bit Architecture) + +### 1.1 Registres generaux + +| Registre | Role AAPCS64 | Sauvegarde | +|-----------|--------------|-----------| +| `x0`-`x7` | Arguments entiers/pointeurs 1 a 8, et valeurs de retour (`x0`, ou `x0`+`x1` pour 128 bits) | caller-saved | +| `x8` | Adresse du resultat indirect (XR) quand la valeur de retour est trop grosse pour les registres. **Sous Linux c est aussi le registre du numero de syscall.** | caller-saved | +| `x9`-`x15`| Temporaires | caller-saved | +| `x16` (IP0), `x17` (IP1) | Registres d appel intra-procedure, utilisables par l editeur de liens pour les veneers. Ne jamais supposer qu ils survivent a un `bl`. | caller-saved | +| `x18` | Registre de plateforme. Sous Linux ELF il est libre, mais d autres environnements (Windows, Darwin, certains SDK) le reservent. **Regle du projet : `x18` est interdit d usage.** Cout nul, portabilite gagnee. | reserve | +| `x19`-`x28` | Variables locales | **callee-saved** | +| `x29` (FP) | Pointeur de trame | **callee-saved** | +| `x30` (LR) | Registre de lien : adresse de retour deposee par `bl`/`blr` | **callee-saved** (a empiler des qu on appelle soi-meme) | +| `sp` | Pointeur de pile. Ce n est pas `x31`. | special | +| `xzr`/`wzr` (encodes 31) | Registre zero : lit 0, absorbe les ecritures | special | + +`w0`-`w30` sont les moities basses 32 bits. **Ecrire dans `wN` met a zero les +32 bits hauts de `xN`.** C est une source de bugs classique quand on manipule +un `int` puis qu on l utilise comme offset 64 bits : il faut un `sxtw` explicite +pour l extension de signe. + +### 1.2 Pile + +- `sp` doit etre **aligne sur 16 octets** a chaque frontiere d appel public + (`bl`, `ret`) et a chaque acces memoire qui l utilise comme base. Un `sp` + desaligne provoque un `SIGBUS` sur AArch64 : ce n est pas une penalite de + performance, c est un plantage. +- La pile croit vers le bas. Prologue standard : + +```asm + stp x29, x30, [sp, #-16]! // empile FP+LR, decremente sp de 16 + mov x29, sp + // ... corps ... + ldp x29, x30, [sp], #16 // depile, reincremente sp + ret +``` + +- Il n existe **pas de red zone** en AAPCS64 : la memoire sous `sp` peut etre + ecrasee a tout instant (signal, debogueur). Toute donnee temporaire doit etre + au-dessus de `sp` apres decrement. +- Reserver de la place se fait en un seul `sub sp, sp, #N` avec N multiple de 16. + +### 1.3 Arguments qui ne tiennent pas dans les registres + +Au-dela de 8 arguments entiers, les suivants passent sur la pile, alignes sur +8 octets, dans l ordre de declaration, a partir de `[sp]` au moment de l appel. +Le projet **n a aucune routine a plus de 8 arguments** ; si le cas se presente, +c est un signal de conception, pas un probleme d ABI a resoudre. + +### 1.4 Registres vectoriels (NEON / SIMD, `v0`-`v31`) + +| Registre | Role AAPCS64 | Sauvegarde | +|-----------|--------------|-----------| +| `v0`-`v7` | Arguments flottants/vectoriels 1 a 8, valeurs de retour | caller-saved | +| `v8`-`v15`| Variables locales — **mais seuls les 64 bits BAS (`d8`-`d15`) sont callee-saved.** Les 64 bits hauts sont caller-saved. | **partiellement callee-saved** | +| `v16`-`v31` | Temporaires | caller-saved | + +Le point `v8`-`v15` est le piege classique : une routine qui utilise `v8` en +128 bits complet doit sauvegarder `d8`, pas `v8`, pour respecter l ABI — et si +elle veut preserver les 128 bits pour son propre compte, c est son affaire, +pas celle de l appelant. + +**Regle du projet :** dans une routine A64 exposee (`.global`), on **n utilise +pas du tout `v8`-`v15`**. On dispose de 24 registres vectoriels caller-saved +(`v0`-`v7`, `v16`-`v31`), ce qui suffit largement pour tous les noyaux de +composition prevus, et cela supprime entierement la question de la +sauvegarde/restauration vectorielle. Si un noyau futur demande plus de 24 +registres vectoriels, c est que son ordonnancement est a revoir. + +`fpsr`/`fpcr` : aucune routine du projet ne modifie le mode d arrondi ni les +drapeaux d exception flottante. Le mode d arrondi est **round-to-nearest-even**, +suppose etabli au demarrage et jamais touche. Cette hypothese est ce qui rend +valide la comparaison octet-a-octet du harnais d oracle (cf. `methode-oracle.md`). + +--- + +## 2. Conventions internes aux routines qui ne suivent pas l AAPCS64 + +Certaines routines de rendu sont des **feuilles** (elles n appellent personne) +et sont appelees exclusivement depuis d autres routines assembleur du meme +fichier. Pour celles-la seulement, on s autorise une convention allegee. + +### 2.1 Classe "routine feuille interne" (suffixe `__leaf`, symbole local `.L`) + +Contraintes : + +1. Elle **n emet aucun `bl`/`blr`**. Consequence : elle n a pas a empiler `x30`. +2. Elle **ne touche pas a `sp`** du tout. Pas de trame, pas de spill. Si elle a + besoin de spiller, elle n est pas une feuille : on la promeut en routine + AAPCS64 normale. +3. Registres qu elle peut ecraser librement : `x0`-`x17` (sauf `x18`, interdit), + `v0`-`v7`, `v16`-`v31`. +4. Registres qu elle doit laisser intacts : `x19`-`x30`, `sp`, `v8`-`v15`. + Autrement dit : **la convention interne n autorise pas a casser plus que + l AAPCS64 n autorise deja.** Elle autorise seulement a *omettre* le + prologue/epilogue. +5. Elle documente en en-tete : ses entrees (registre par registre), ses sorties, + et la liste exacte des registres qu elle detruit. + +Ce choix est deliberement conservateur. Une convention exotique +(`x19` accumulateur global, par exemple) ferait gagner un registre et couterait +une classe entiere de bugs non reproductibles a chaque insertion d appel. Le +pilier 1 (determinisme) inclut le determinisme du debogage. + +### 2.2 Registres a usage reserve global + +**Il n y en a aucun.** Aucun registre ne porte de valeur vivante entre deux +routines du projet. Pas de pointeur de contexte permanent en `x28`, pas de base +de framebuffer en `x27`. + +Raison : un registre reserve globalement est un etat cache. Il oblige chaque +nouvelle routine a connaitre une convention non exprimee dans sa signature, et +il rend tout appel vers du code externe (ou genere par le compilateur) +potentiellement destructeur. Le gain — economiser un `ldr` par routine — est +sans commune mesure avec le cout. + +Cette decision est **definitive**. Si elle devait etre revue, ce serait par un +ADR dedie, pas par un commentaire dans un `.S`. + +--- + +## 3. Nommage des symboles et visibilite + +### 3.1 Nommage + +- Tout symbole assembleur visible depuis le C++ est declare `extern "C"` cote + C++ et prefixe `proj3_` cote assembleur. +- Forme : `proj3__`, en minuscules, mots separes par `_`. + Exemples : `proj3_sys_write`, `proj3_fill_bytes_asm`. +- Les routines qui sont la version assembleur d une paire d oracle portent le + suffixe `_asm`. La version C++ de reference porte le suffixe `_ref`. + Une version volontairement fausse (test du harnais) porte `_asm_broken`. +- Les symboles locaux a un fichier commencent par `.L` : l assembleur ne les + emet pas dans la table des symboles, ils n apparaissent donc ni dans `nm` ni + dans les traces. +- Les etiquettes de boucle internes sont `.L_` : + `.Lfill_bytes_loop`, `.Lfill_bytes_tail`. Jamais `1:` / `1b`, illisible en + revue. + +### 3.2 Visibilite — boilerplate obligatoire + +Toute routine exportee est declaree exactement ainsi : + +```asm + .text + .balign 4 + .global proj3_exemple + .hidden proj3_exemple // pas d export dynamique : rien a interposer + .type proj3_exemple, %function +proj3_exemple: + // ... + ret + .size proj3_exemple, . - proj3_exemple +``` + +- `.balign 4` : toutes les instructions A64 font 4 octets ; l alignement + explicite protege des sections concatenees a la main. +- `.hidden` : le binaire est statique et sans libc, aucune interposition n a de + sens. Cela evite au passage toute entree de PLT. +- `.type`/`.size` : necessaires pour que `llvm-objdump`, `perf` et un debogueur + retrouvent les bornes de la fonction. Un `.size` manquant donne des profils + inexploitables — ce qui, sur un projet dont la these est la mesure de latence, + est disqualifiant. + +### 3.3 Sections + +- Code : `.text`. +- Constantes en lecture seule : `.section .rodata,"a",@progbits`. +- **Aucune section `.data` ni `.bss` dans un fichier `.S`.** Toute donnee + mutable vit dans une arene (cf. chantier 3). Un `.S` qui declare de l etat + mutable contourne le budget memoire explicite du pilier 2. +- Aucun fichier `.S` n emet de section a la fois executable et inscriptible. +- Chaque `.S` se termine par `.section .note.GNU-stack,"",@progbits` afin que + l editeur de liens ne marque pas la pile executable. + +--- + +## 4. Notes de portabilite entre les deux cibles materielles + +- Pixel 3a (`sargo`) : Snapdragon 670, coeurs Kryo 360 (Cortex-A75/A55), + ARMv8.0-A avec extensions ARMv8.2 partielles. **Ne pas supposer** la presence + de LSE (atomiques `casal`), de dotprod, ni de FP16 arithmetique. +- Poco F5 Pro (`mondrian`) : SD 8+ Gen 1, ARMv8.4+, beaucoup plus riche. +- **Regle : le code assembleur ecrit ne suppose que la base ARMv8.0-A + NEON.** + Toute utilisation d une extension doit passer par une detection au runtime + (lecture de `AT_HWCAP` dans l auxiliary vector) et un chemin de repli, sur le + modele du repli memoire du chantier 3. Aucune extension n est utilisee a ce + jour. diff --git a/doc/convention-syscall.md b/doc/convention-syscall.md new file mode 100644 index 0000000..64e2b03 --- /dev/null +++ b/doc/convention-syscall.md @@ -0,0 +1,152 @@ +# Convention de remontee d erreur syscall — decision definitive + +Statut : **arrete**. Une seule convention dans tout le projet. Tout code qui +appelle un wrapper syscall suit celle-ci, sans exception ni variante locale. + +--- + +## 1. Le probleme + +Le noyau Linux ne dispose pas d `errno`. Sur AArch64, `svc #0` place dans `x0` +soit le resultat de l appel, soit **l oppose du code d erreur**. Un resultat +est une erreur si et seulement si : + +``` +-4095 <= x0 <= -1 +``` + +La borne `-4095` n est pas decorative : `MAX_ERRNO` vaut 4095 dans le noyau +(`include/linux/err.h`), et c est exactement ce que fait la macro +`IS_ERR_VALUE`. Certains appels retournent legitimement des valeurs negatives +hors de cette plage — `lseek` sur un fichier de plus de 8 exaoctets, `mmap` +retournant une adresse dont le bit 63 est a 1 sur une configuration a 64 bits +d espace utilisateur. Un test approximatif du genre `if (ret < 0)` est donc +**faux**, pas seulement imprecis. + +C est la libc qui, normalement, traduit cela en `-1` + `errno`. Sans libc, +il faut choisir. + +--- + +## 2. Options envisagees + +### Option A — Valeur sentinelle plus etat global (mimer errno) + +Le wrapper retourne `-1` en cas d echec et depose le code dans une variable +globale `proj3_last_errno`. + +| Pilier | Evaluation | +|---|---| +| 1. Determinisme de latence | Neutre en soi, mais impose une variable globale mutable. Des qu on aura plus d un fil d execution ou un gestionnaire de signal, il faut du stockage par contexte : c est le chemin qui mene a `__errno_location()`, donc a un appel indirect non inlinable sur le chemin chaud. | +| 2. Budget memoire explicite | Une section `.data`/`.bss` mutable hors arene. Contredit directement la regle "toute donnee mutable vit dans une arene" (`convention-aarch64.md` 3.3). | +| 3. Acces direct justifie | C est reconstruire la couche libc qu on a explicitement decide de ne pas avoir. Abstraction non justifiee. | + +Verdict : **rejetee**. Elle detruit l information (deux appels, le second +ecrase le code du premier) et introduit un etat global cache. + +### Option B — Structure de retour `{ valeur, code_erreur }` + +Le wrapper retourne un agregat de deux `i64`. + +| Pilier | Evaluation | +|---|---| +| 1. Determinisme de latence | Un agregat de 16 octets rentre dans `x0`+`x1` en AAPCS64, donc pas de retour indirect ni de trafic memoire. Cout nul en theorie. En pratique, cela oblige chaque wrapper assembleur a produire deux registres, donc a tester la plage d erreur **dans** le wrapper : une comparaison et un `csel` par appel, meme quand l appelant ignore l erreur. | +| 2. Budget memoire | Rien a allouer. Correct. | +| 3. Acces direct | La valeur brute rendue par le noyau est deja porteuse des deux informations. Les scinder puis les recombiner cote appelant est du travail ajoute pour rien. | + +Verdict : **rejetee**, mais de peu. Le seul reproche serieux est le travail +inconditionnel dans le wrapper alors que la meme information est disponible +gratuitement. + +### Option C — Valeur brute du noyau, encapsulee dans un type a cout nul + +Le wrapper retourne exactement ce que `svc #0` a mis dans `x0`, tel quel. Cote +C++, ce `i64` est enveloppe dans une structure d un seul membre, +`proj3::sys::Result`, dont toutes les methodes sont `constexpr` et inlinees : +`is_err()`, `err()`, `value()`, `ptr()`, `fd()`. + +| Pilier | Evaluation | +|---|---| +| 1. Determinisme de latence | Le wrapper assembleur ne fait **rien** apres le `svc` : `svc #0 ; ret`. Cout strictement minimal et constant. Le test de plage n est paye que par l appelant qui le demande. | +| 2. Budget memoire | Aucun etat, aucune allocation, aucune section mutable. | +| 3. Acces direct | Zero couche : la valeur traversee est celle du noyau, bit pour bit. La structure n existe qu au niveau du type, pas a l execution (`sizeof == 8`, trivialement copiable, passee en registre). | + +Verdict : **retenue.** + +--- + +## 3. Convention retenue + +### 3.1 Cote assembleur + +Chaque wrapper est de la forme : + +```asm +proj3_sys_: + mov x8, #PROJ3_NR_ + svc #0 + ret +``` + +Aucune transformation. La valeur de retour est le `x0` du noyau. +Consequence directe : **aucun wrapper n a de prologue, ne touche a `sp`, ni +n empile `x30`.** L alignement de pile est preserve trivialement. + +### 3.2 Cote C++ + +```cpp +namespace proj3::sys { + +// Valeur de retour brute d un appel systeme Linux. +// sizeof == 8, trivialement copiable : passee et rendue en registre. +struct Result { + i64 raw; + + // Plage d erreur exacte du noyau : [-4095, -1]. Ni approximative, + // ni "raw < 0". + constexpr bool is_err() const { return raw < 0 && raw >= -4095; } + constexpr bool is_ok() const { return !is_err(); } + + // Code errno positif. Precondition : is_err(). + constexpr i32 err() const { return static_cast(-raw); } + + // Valeur utile. Precondition : is_ok(). + constexpr i64 value() const { return raw; } + constexpr i32 fd() const { return static_cast(raw); } + void* ptr() const { return reinterpret_cast(raw); } +}; + +} +``` + +### 3.3 Regles d usage — obligatoires + +1. **Toute valeur `Result` est testee avec `is_err()` avant tout usage de + `value()`, `fd()` ou `ptr()`.** Il n existe pas de conversion implicite vers + un entier ou un booleen : le type ne se laisse pas utiliser par accident. +2. **Ignorer un `Result` est explicite.** Le type est marque + `[[nodiscard]]` ; l ignorer demande d ecrire `(void)`. Le seul cas ou c est + legitime est `close()` en chemin de sortie. +3. **Aucun code du projet ne stocke un `errno`.** Un code d erreur est traite + la ou il apparait : soit il est recuperable et le chemin de repli est pris + sur place (c est le cas du repli `MAP_HUGETLB` -> THP -> `mmap` simple), + soit il ne l est pas et on appelle `panic()` avec le nom de l appel et le + code. Rien n est mis de cote pour plus tard. +4. **`EINTR` n est jamais reessaye en boucle silencieuse.** Une boucle de + retry est une latence non bornee, donc une violation du pilier 1. Le projet + n installe aucun gestionnaire de signal ; si `EINTR` apparait, c est un + evenement inattendu et il doit remonter. +5. Les constantes `errno` utilisees sont definies dans + `src/proj3/sys/errno.hpp`, avec leur source. On ne definit que celles qu on + teste effectivement. + +### 3.4 Ce que cette convention coute + +- L appelant doit se souvenir que `mmap` peut legitimement rendre un pointeur + dont la valeur signee est negative hors plage d erreur. `is_err()` gere ce + cas correctement, mais un appelant qui ecrirait `if (r.raw < 0)` a la main + aurait tort. C est le seul piege, et il est nomme ici. +- Il n y a pas de message d erreur lisible associe a un code. On imprime le + numero. Une table `errno -> chaine` couterait plusieurs kilooctets de + `.rodata` pour du confort de debogage ; si elle devient necessaire, elle sera + conditionnee a un build de debogage, par un ADR. diff --git a/doc/memoire.md b/doc/memoire.md new file mode 100644 index 0000000..df6d846 --- /dev/null +++ b/doc/memoire.md @@ -0,0 +1,187 @@ +# Memoire — trois modes de pages, cinq arenes, un garde-fou + +## 1. Les trois modes, et ce qu ils valent + +L acquisition des pages (`src/proj3/mem/page_source_linux.cpp`) essaie trois +chemins **dans l ordre**, au demarrage, **dans un seul binaire** : + +| ordre | appel | mode retenu | +|---|---|---| +| 1 | `mmap(MAP_HUGETLB \| MAP_HUGE_2MB)` | `HugeMode::Hugetlb2MB` | +| 2 | `mmap` classique puis `madvise(MADV_HUGEPAGE)` | `HugeMode::TransparentHuge` | +| 3 | `mmap` classique seul | `HugeMode::PlainPages` | + +C est exactement l esprit du repli OpenGL/GDI de Gastinel Write : detection au +runtime, un seul binaire, aucune question a l utilisateur, et le mode +effectivement retenu est journalise et interrogeable par le programme. + +### Ils n ont PAS les memes proprietes de determinisme + +C est le point central, pas une note de bas de page. + +**`Hugetlb2MB`** — les pages viennent du pool hugetlbfs, reservees d avance. +Elles ne sont ni deplacees, ni fusionnees, ni recuperees, ni scindees. Une +entree de TLB couvre 2 Mo. **Les mesures de latence faites dans ce mode sont +valides.** + +**`TransparentHuge`** — le noyau *peut* promouvoir la region en huge pages, ou +pas. Il le fait par un fil de fond, `khugepaged`, dont l ordonnancement nous +echappe totalement. Une promotion — ou une scission — peut se produire +**pendant** une mesure. **Toute mesure de latence faite dans ce mode porte une +barre d erreur inconnue** et doit etre annotee comme telle. Le mode est +utilisable, le chiffre qui en sort ne l est pas sans reserve. + +**`PlainPages`** — pages de 4 Ko. Comportement previsible, mais couvrir les +9,6 Mo de scanout demande environ 2342 entrees de TLB, ce qui depasse la TLB +de second niveau d un Cortex-A75. Les manques de TLB deviennent alors une +source de variance mesurable. **Le mode est correct, pas rapide.** + +**`HostEmulated`** — cible hote uniquement, memoire fournie par `malloc`. +Aucune garantie d aucune sorte. Ce mode existe pour que le harnais tourne sur +la machine de dev, et pour qu il soit **impossible** de confondre un chiffre +obtenu sur un x86 de bureau avec un chiffre obtenu sur le telephone. + +### Savoir lequel est actif + +```cpp +#include "proj3/mem/page_source.hpp" + +proj3::mem::HugeMode m = proj3::mem::active_mode(); +const char* nom = proj3::mem::huge_mode_name(m); // "HUGETLB-2MB", ... +bool mesurable = proj3::mem::mode_is_deterministic(m); // true pour Hugetlb2MB seul +proj3::mem::log_active_mode(); // journalise + avertit +``` + +`log_active_mode()` ecrit sur la sortie d erreur, au demarrage, quelque chose +comme : + +``` +proj3: memoire : mode retenu = PAGES-4K +proj3: memoire : ATTENTION, pages NON garanties. +proj3: memoire : toute mesure de latence faite dans ce mode +proj3: memoire : porte une barre d erreur inconnue. +``` + +### Attention : `MAP_HUGETLB` n est pas suppose disponible + +Sa presence sur le noyau stock du Pixel 3a **n a pas ete verifiee +materiellement**. Sur un noyau Android par defaut, `nr_hugepages` vaut zero et +le pool est vide : le chemin 1 echouera avec `ENOMEM`. C est precisement +pourquoi le repli existe et pourquoi il est teste des le premier demarrage. + +`MAP_HUGE_2MB` est passe explicitement. Sans lui, `MAP_HUGETLB` utilise la +taille de huge page par defaut du systeme, qui peut valoir 512 Mo sur certaines +configurations arm64 — l appel echouerait alors pour une raison difficile a +diagnostiquer. + +## 2. Les cinq arenes + +Un **seul** `mmap` est fait, puis decoupe. Raison : le repli huge pages ne vaut +que sur une region contigue. Cinq `mmap` separes auraient cinq modes +potentiellement differents, et la question « quel mode est actif ? » n aurait +plus de reponse unique. + +Toutes les tailles sont dans `src/proj3/mem/layout.hpp`, en `constexpr`, avec +leur calcul. Dimensionnement **Pixel 3a : 4 Go de RAM, 1080x2220**. + +| arene | taille | calcul | +|---|---:|---| +| `scanout` | 19 185 664 | `1080*2220*4 = 9 590 400` par tampon, arrondi a la page (9 592 832), **deux** tampons. Double buffering, pas triple : un troisieme tampon ajoute une image entiere de latence, ce que le projet combat. | +| `geometrie` | 2 097 152 | Une arete = 20 octets. Pire cas raisonne : ~600 points de contour, chaque quadratique subdivisee au plus 64 fois -> 38 400 aretes = 768 000 octets. 2 Mo laisse la place d y ajouter un trace d interface dans la meme passe. | +| `atlas` | 2 097 152 | Couverture 8 bits. Trois corps (16/24/32 px), cellule `(corps+2)^2` : 324 + 676 + 1156 = 2156 octets par glyphe. 256 glyphes (Latin-1 + ponctuation) = 551 936 octets. Facteur 3,8 de marge pour un quatrieme corps ou une graisse. | +| `entree` | 131 072 | Evenement normalise = 32 octets. Ecran tactile : ~200 evt/s par contact, 10 contacts = 2000 evt/s. 4096 emplacements = plus de deux secondes de rafale. | +| `scratch` | 2 097 152 | Remis a zero a chaque image. Majorant des intersections de balayage : 38 400 croisements de 8 octets = 307 200 octets, plus les tampons de composition par tuiles. | + +**Total decoupe : 25 608 192 octets.** Le bloc demande au noyau est arrondi au +multiple superieur de 2 Mo — `MAP_HUGETLB` exige une longueur multiple de la +taille de huge page — soit **27 262 976 octets (26 Mo)**. Le reliquat de +1 654 784 octets n est pas perdu : il est expose comme `kReserveBytes`. + +Soit **0,63 % des 4 Go du Pixel 3a**. + +### Comportement + +- Allocation = avance de pointeur, avec alignement calcule **sur l offset** et + non sur l adresse. La base d une arene etant alignee sur 2 Mo, cela revient + au meme — mais cela rend le comportement rigoureusement identique entre + l hote et la cible, ce qui compte pour le harnais d oracle. +- **Pas de liberation individuelle.** Un `reset()` global par arene, un + `mark()` / `rewind_to()` pour les usages en pile. +- **Un debordement est une panique**, jamais un agrandissement. Le message + donne le nom de l arene, la taille demandee, l alignement, l occupation et la + capacite : + +``` +proj3: PANIQUE: debordement d arene 'geometrie' : demande=4194304 align=8 occupe=0 capacite=2097152 + Un debordement d arene est un defaut de conception, pas un cas + a gerer : corriger le calcul dans mem/layout.hpp. +``` + +- `Arena::peak()` donne la plus haute occupation atteinte. C est la seule + metrique qui permette de dire si une taille de `layout.hpp` est juste ou + fantaisiste. Cout : une comparaison par allocation. + +## 3. Le garde-fou + +`src/proj3/mem/new_guard.cpp` redefinit `operator new`, `operator new[]`, +`operator delete`, `operator delete[]`, ainsi que leurs formes dimensionnees et +alignees. Toutes tuent le processus immediatement : + +``` +proj3: ALLOCATION INTERDITE: operator new[] taille=64 + Le projet n alloue rien apres l init. Tout passe par une arene + (mem/arena.hpp). Poser un point d arret sur operator new et + remonter la pile pour trouver l appelant. +``` + +Code de sortie **71**, distinct du **70** de `panic()`, pour qu un script sache +que c est une allocation et pas autre chose. + +**Ce que le garde-fou n attrape pas**, et il faut le savoir : +- `malloc` / `calloc` / `realloc` / `free` appeles directement. Ce sont des + fonctions C, sans rapport avec `operator new`. Sur la cible embarquee la + question ne se pose pas (le lien echouerait). Sur l hote, + `page_source_host.cpp` les utilise deliberement. +- les allocations faites par le noyau (pile, `mmap`) ; +- les VLA et `alloca`, qui prennent sur la pile. + +Le perimetre est donc exactement : **aucun `new` C++ nulle part**. C est ce +qu on veut verifier. + +**Il est en bibliotheque separee** (`proj3_newguard`) et n est lie qu aux +executables qui pretendent ne rien allouer. Le lier partout casserait tout +outil utilisant la STL de l hote — ce qui est le comportement recherche, mais +doit etre choisi executable par executable. + +Preuve qu il fonctionne : `test/test_new_guard.cpp`, declare `WILL_FAIL TRUE` +dans CTest. Le test est reussi si et seulement si le processus meurt. + +## 4. A REVERIFIER lors du passage a la cible 12 Go (Poco F5 Pro) + +Cette section est le point de reprise. Rien de ce qui suit n est fait. + +1. **La resolution change.** Le Poco F5 Pro est en 1440x3200. Le calcul du + scanout devient `1440*3200*4 = 18 432 000` par tampon, soit **36 Mo pour + deux** au lieu de 19 Mo. `kScreenWidth` / `kScreenHeight` doivent devenir + des parametres, pas des constantes — et la question « constexpr ou lu depuis + DRM ? » se posera : une taille lue au runtime interdit le dimensionnement + `constexpr` des arenes, ce qui est un changement d architecture, pas un + ajustement. +2. **La taille de page peut differer.** Certains noyaux arm64 recents sont + compiles en pages de 16 Ko. `kPageSize` doit alors changer ; `kHugePageSize` + passerait de 2 Mo (PMD sur 4K) a 32 Mo (PMD sur 16K), ce qui invaliderait + `MAP_HUGE_2MB`. +3. **`MAP_HUGETLB` a peut-etre plus de chances d aboutir** sur un noyau plus + recent — ou pas. A verifier materiellement, pas a supposer. Si le mode 1 + devient disponible sur une cible et pas sur l autre, les mesures des deux + cibles ne sont **pas comparables entre elles**. +4. **Les tailles d atlas et de geometrie ne doivent PAS etre augmentees + mecaniquement.** Elles sont dimensionnees par un raisonnement (nombre de + glyphes, nombre d aretes), pas par un pourcentage de la RAM. Plus de RAM ne + justifie pas plus d atlas ; une densite de pixels plus elevee, qui impose des + corps plus grands, oui — et il faudra refaire le calcul, pas le doubler. +5. **`kArenaTotal < RAM/64` deviendra trivialement vrai** et cessera d etre un + garde-fou utile. Le remplacer par une borne absolue reflechie. +6. **Le pic reel doit etre releve avant de retoucher quoi que ce soit.** + `Arena::peak()` existe pour cela. Redimensionner sans avoir regarde les pics + sur la cible actuelle serait du reglage a l aveugle. diff --git a/doc/methode-oracle.md b/doc/methode-oracle.md new file mode 100644 index 0000000..081c296 --- /dev/null +++ b/doc/methode-oracle.md @@ -0,0 +1,172 @@ +# Methode de l oracle — validation croisee C++ / assembleur + +## 1. La regle + +Toute routine critique du projet existe en **deux exemplaires** : + +- une **version de reference en C++**, ecrite d abord, lisible, evidemment + correcte, jamais optimisee ; +- une **version assembleur**, ecrite ensuite, rapide, et suspecte jusqu a + preuve du contraire. + +Le harnais execute les deux sur les memes entrees et compare les sorties +**octet par octet**. Pas d epsilon, pas de tolerance, pas de "presque". + +## 2. La regle qui compte vraiment + +> **La version C++ de reference n est JAMAIS supprimee.** + +Meme quand la version assembleur est validee. Meme quand elle tourne depuis +deux ans sans incident. Meme quand la version C++ n est plus compilee en +production. + +Raisons, dans l ordre d importance : + +1. **Sans reference, il n y a plus d oracle.** Le jour ou l assembleur se met + a produire un resultat different apres un changement de compilateur, de + modele de CPU ou de flag, il n y a plus rien a quoi le comparer. On aurait + un bug et aucun moyen de dire ou. +2. **La reference est la specification.** Elle dit ce que la routine doit + faire, dans un langage que quelqu un peut lire dans cinq ans. Le commentaire + d en-tete d une routine NEON, non. +3. **Elle est le chemin de repli.** Un portage vers une architecture sans notre + assembleur (un simulateur, une machine de dev, une future cible) reste + possible tant qu elle existe. + +La selection production/reference est un choix de compilation, jamais une +suppression de code. + +## 3. Ce que le harnais garantit, et ce qu il ne garantit pas + +Garanti : +- egalite exacte des octets de sortie ; +- egalite exacte de la longueur rendue ; +- absence de debordement du tampon de sortie, y compris d **un seul octet** + (zone de garde de 32 octets remplie de `0xA5`, verifiee apres chaque appel) ; +- absence d allocation dynamique, quand l executable est lie a + `proj3_newguard` — c est le cas de `proj3_oracle`. + +Non garanti, et il faut le savoir : +- **la performance**. Ce harnais valide la correction, rien d autre. La mesure + de latence est un chantier distinct, plus tard, avec son propre outillage. +- **la couverture**. Le harnais teste ce qu on lui donne. Les cas explicites + sont ecrits a la main, le reste est aleatoire reproductible. + +## 4. Ajouter une paire + +Trois choses a ecrire, aucune modification du harnais : + +```cpp +#include "oracle.hpp" + +namespace proj3::oracle { + +// 1. la reference C++ +usize ma_routine_ref(const u8* in, usize in_len, u8* out, usize out_cap) { ... } + +// 2. les cas +const CaseSpec kMesCas[] = { + {"vide", 0, 0, 0, 0}, + {"16 octets", 16, 0, 0, 0}, + {"desaligne +1/+3", 256, 0, 1, 3}, + {"aleatoire", 4096, 0xDEADBEEFCAFEBABEull, 0, 0}, +}; + +// 3. l enregistrement +PROJ3_ORACLE_PAIR(ma_routine, "mon::module::ma_routine", + &ma_routine_ref, &proj3_ma_routine_asm, kMesCas); +} +``` + +`opt` peut valoir `nullptr` : la paire est alors enregistree comme +**reference figee**, la reference est executee seule (ce qui verifie deja +qu elle ne plante pas, ne deborde pas et n alloue pas), et le harnais l affiche +comme telle. C est ainsi qu on enregistre une routine **avant** d avoir ecrit +son assembleur — ce que fait `pairs_render.cpp` pour tout le pipeline de +rendu du chantier 5. + +Le champ `CaseSpec` : + +| champ | role | +|---|---| +| `label` | affiche en cas d echec ; ecrire de quoi identifier le cas | +| `in_len` | taille de l entree, qui vaut aussi capacite de la sortie | +| `seed` | 0 = motif deterministe ; sinon graine du xorshift64* | +| `in_align_offset` | decalage en octets de la base d entree | +| `out_align_offset` | decalage en octets de la base de sortie | + +Les tampons viennent d une arene dont la base est alignee sur 2 Mo : un +decalage de *k* octets donne donc une adresse congrue a *k* modulo 16, ce qui +est exactement le levier dont un chemin NEON a besoin pour etre teste des deux +cotes. + +## 5. Le diagnostic + +En cas de divergence, le harnais affiche : + +``` +ECHEC fill_bytes (VERSION FAUSSE) / 16 (128 bits pile) + octet divergent + rejouer ce cas : graine=0 in_len=16 align_in=+0 align_out=+0 + longueurs : reference=16 optimisee=16 + premier octet divergent a l offset 15 : attendu=0x5b obtenu=0x0 + attendu [0..16) : 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b + obtenu [0..16) : 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 5b 00 +``` + +Tout est la pour rejouer exactement le cas : la graine, la longueur, les deux +alignements. Le contexte de 16 octets de part et d autre permet de distinguer +d un coup d oeil un decalage d une valeur fausse. + +## 6. Validation du harnais lui-meme + +`proj3_oracle_selftest` execute deux passes sur la meme paire de +demonstration : + +1. la version assembleur **correcte** doit etre acceptee ; +2. la version assembleur **volontairement fausse** (un octet de moins ecrit, + longueur rendue correcte — le genre de bug qu un test indulgent laisse + passer) doit etre **rejetee**. + +Le test rend 0 seulement si les deux attentes sont satisfaites. + +> Un harnais qui ne sait pas detecter une erreur connue ne vaut rien. C est +> pour cela que la version fausse existe et qu elle reste dans le depot. + +## 7. Ou tourne quoi — limite assumee + +| executable | cible | ce qu il compare | +|---|---|---| +| `proj3_oracle` | hote | reference C++ contre asm **x86-64**, pour la paire de demonstration seulement. Les autres paires sont en reference figee. | +| `proj3_oracle_selftest` | hote | la meme paire, correcte puis fausse | +| `proj3_oracle_target` | AArch64 | reference C++ contre asm **AArch64**, toutes paires | + +La machine de developpement ne peut pas executer de l AArch64. Pour que la +preuve « le harnais sait rejeter une erreur » puisse etre faite **sur la +machine de dev**, la paire de demonstration est ecrite deux fois : +`asm/demo_fill_aarch64.S` et `asm/host/demo_fill_x86_64.S`. + +**Ce doublon ne sera pas etendu.** Les vraies routines optimisees seront +ecrites en AArch64 seulement ; leur comparaison se fera sur la cible, avec +`proj3_oracle_target`. Sur l hote elles apparaitront comme « reference figee, +version assembleur absente ». C est une limite de la double cible, pas un +oubli. + +## 8. Hypotheses numeriques + +La comparaison octet-a-octet entre l hote et la cible n a de sens que si les +deux calculent rigoureusement pareil. Ce qui est suppose, et pourquoi c est +vrai : + +| hypothese | justification | +|---|---| +| `float` = IEEE-754 binary32, `double` = binary64 | vrai sur AArch64 et x86-64 | +| mode d arrondi round-to-nearest-even | valeur par defaut, et aucune routine du projet ne touche `fpcr` ni `mxcsr` (regle inscrite dans `convention-aarch64.md` 1.4) | +| pas de precision excedentaire | x86-64 calcule en SSE2, pas en x87 80 bits ; AArch64 n a pas de format etendu | +| `sqrt` correctement arrondi | `fsqrt` (A64) et `sqrtsd` (SSE2) le sont, par la norme | +| pas de `-ffast-math` | seul `-fno-math-errno` est utilise, et il ne change aucune valeur : il supprime uniquement la mise a jour d `errno`, dont le projet n a pas | +| little-endian des deux cotes | `static_assert` sur `__BYTE_ORDER__` dans `base/types.hpp` | + +Si l une de ces hypotheses tombait, le harnais deviendrait un generateur de +faux positifs. Elles sont donc listees ici, et non enfouies dans un +commentaire. diff --git a/src/proj3/base/cstring.cpp b/src/proj3/base/cstring.cpp new file mode 100644 index 0000000..2ca513b --- /dev/null +++ b/src/proj3/base/cstring.cpp @@ -0,0 +1,58 @@ +// base/cstring.cpp — les quatre symboles que le compilateur peut emettre seul. +// +// COMPILE UNIQUEMENT POUR LA CIBLE EMBARQUEE. Sur l hote, la libc les fournit +// et les redefinir provoquerait un conflit de symboles. +// +// Pourquoi ce fichier existe : meme avec -nostdlib -ffreestanding, GCC et +// Clang se reservent le droit de transformer une boucle de copie ou une +// initialisation d agregat en appel a memcpy / memset / memmove / memcmp. +// C est documente et parfaitement legal de leur part. Sans ces definitions, +// le lien echoue avec un symbole indefini au moment le moins pratique. +// +// -fno-builtin est passe a la compilation pour eviter que le compilateur ne +// reconnaisse ces definitions et ne les remplace par un appel a elles-memes. + +#include "proj3/base/types.hpp" + +using proj3::i32; +using proj3::u8; +using proj3::usize; + +extern "C" { + +void* memset(void* dst, int value, usize n) { + u8* p = static_cast(dst); + const u8 v = static_cast(value); + for (usize i = 0; i < n; ++i) p[i] = v; + return dst; +} + +void* memcpy(void* dst, const void* src, usize n) { + u8* d = static_cast(dst); + const u8* s = static_cast(src); + for (usize i = 0; i < n; ++i) d[i] = s[i]; + return dst; +} + +void* memmove(void* dst, const void* src, usize n) { + u8* d = static_cast(dst); + const u8* s = static_cast(src); + if (d == s || n == 0) return dst; + if (d < s) { + for (usize i = 0; i < n; ++i) d[i] = s[i]; + } else { + for (usize i = n; i-- > 0;) d[i] = s[i]; + } + return dst; +} + +int memcmp(const void* a, const void* b, usize n) { + const u8* x = static_cast(a); + const u8* y = static_cast(b); + for (usize i = 0; i < n; ++i) { + if (x[i] != y[i]) return static_cast(x[i]) - static_cast(y[i]); + } + return 0; +} + +} // extern "C" diff --git a/src/proj3/base/fmt.hpp b/src/proj3/base/fmt.hpp new file mode 100644 index 0000000..dfe1fc8 --- /dev/null +++ b/src/proj3/base/fmt.hpp @@ -0,0 +1,68 @@ +// base/fmt.hpp — formatage entier minimal, freestanding, sans allocation. +// +// Chaque fonction ecrit dans un tampon fourni par l appelant et rend le +// nombre d octets ecrits. Aucun etat, aucune allocation, aucun appel a la +// libc : utilisable depuis un chemin de panique. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3 { + +inline usize str_len(const char* s) { + usize n = 0; + while (s[n] != '\0') ++n; + return n; +} + +// Tampon minimal : 20 chiffres pour un u64, 21 avec le signe d un i64. +inline constexpr usize kDecBufSize = 24; + +inline usize fmt_u64(char* out, usize cap, u64 v) { + char tmp[kDecBufSize]; + usize n = 0; + do { + tmp[n++] = static_cast('0' + (v % 10u)); + v /= 10u; + } while (v != 0 && n < sizeof(tmp)); + if (n > cap) return 0; + for (usize i = 0; i < n; ++i) out[i] = tmp[n - 1 - i]; + return n; +} + +inline usize fmt_i64(char* out, usize cap, i64 v) { + if (v >= 0) return fmt_u64(out, cap, static_cast(v)); + if (cap == 0) return 0; + out[0] = '-'; + // Negation via u64 : -v deborde pour v == INT64_MIN, pas la soustraction + // depuis zero en non signe. + const u64 mag = 0u - static_cast(v); + const usize n = fmt_u64(out + 1, cap - 1, mag); + return n == 0 ? 0 : n + 1; +} + +inline usize fmt_hex_u64(char* out, usize cap, u64 v) { + static const char kDigits[] = "0123456789abcdef"; + char tmp[16]; + usize n = 0; + do { + tmp[n++] = kDigits[v & 0xFu]; + v >>= 4; + } while (v != 0 && n < sizeof(tmp)); + if (n + 2 > cap) return 0; + out[0] = '0'; + out[1] = 'x'; + for (usize i = 0; i < n; ++i) out[2 + i] = tmp[n - 1 - i]; + return n + 2; +} + +// Deux chiffres hexadecimaux, sans prefixe : pour les vidages d octets. +inline usize fmt_hex_u8(char* out, usize cap, u8 v) { + static const char kDigits[] = "0123456789abcdef"; + if (cap < 2) return 0; + out[0] = kDigits[(v >> 4) & 0xFu]; + out[1] = kDigits[v & 0xFu]; + return 2; +} + +} // namespace proj3 diff --git a/src/proj3/base/math.hpp b/src/proj3/base/math.hpp new file mode 100644 index 0000000..c06edab --- /dev/null +++ b/src/proj3/base/math.hpp @@ -0,0 +1,84 @@ +// base/math.hpp — le strict minimum de mathematiques flottantes, sans libm. +// +// HYPOTHESES, valables sur les deux cibles et verifiees par static_assert +// autant que le langage le permet : +// - float est IEEE-754 binary32, double est binary64 ; +// - le mode d arrondi est round-to-nearest-even et personne ne le change ; +// - x86-64 calcule en SSE2, pas en x87 80 bits : pas de precision excedentaire +// surprise. (C est vrai par defaut pour tout compilateur 64 bits.) +// - aucune option de type -ffast-math n est utilisee. +// Ces hypotheses sont ce qui rend la comparaison octet-a-octet du harnais +// d oracle valide entre l hote et la cible. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3 { + +using f32 = float; +using f64 = double; + +static_assert(sizeof(f32) == 4 && sizeof(f64) == 8); + +template +constexpr T min_of(T a, T b) { + return a < b ? a : b; +} +template +constexpr T max_of(T a, T b) { + return a > b ? a : b; +} +template +constexpr T clamp_to(T v, T lo, T hi) { + return v < lo ? lo : (v > hi ? hi : v); +} + +// floor / ceil par troncature entiere. +// +// Valide seulement pour |v| < 2^62, ce qui est garanti ici : toutes les +// coordonnees manipulees sont bornees par la taille de l ecran multipliee par +// l echelle, soit quelques milliers. Un garde-fou explicite plutot qu une +// implementation generale : le cas general n existe pas dans ce projet. +inline f32 floor_f32(f32 v) { + const i64 t = static_cast(v); + const f32 tf = static_cast(t); + return (tf > v) ? tf - 1.0f : tf; +} + +inline f32 ceil_f32(f32 v) { + const i64 t = static_cast(v); + const f32 tf = static_cast(t); + return (tf < v) ? tf + 1.0f : tf; +} + +// Arrondi a l entier le plus proche, moitie loin de zero. +// C est exactement la semantique de std::lround, celle qu utilisait le code +// d origine pour l avance des glyphes. Ne pas la changer : elle est visible +// dans la position de chaque caractere. +inline i32 lround_f32(f32 v) { + return v >= 0.0f ? static_cast(v + 0.5f) : -static_cast(-v + 0.5f); +} + +// Racine carree. __builtin_sqrt se compile en une instruction machine +// (fsqrt sur AArch64, sqrtsd sur x86-64), toutes deux correctement arrondies +// par IEEE-754 : le resultat est bit-a-bit identique sur les deux cibles. +// Aucun appel a libm n est emis. +inline f64 sqrt_f64(f64 v) { return __builtin_sqrt(v); } + +// Longueur euclidienne. +// +// DIVERGENCE CONNUE AVEC LE CODE D ORIGINE, documentee ici parce qu elle est +// la seule du portage : Gastinel Write utilise std::hypot, qui evite le +// debordement intermediaire et peut etre plus precis d un ULP que le calcul +// naif. On n a pas de libm, donc on calcule naivement — mais en double, ce qui +// rend l ecart avec hypot inferieur a un ULP de float. +// +// Consequence possible : subdivision_count() pourrait choisir un nombre de +// segments different, si et seulement si d/1.5 tombait exactement sur un +// entier a un ULP pres. Le test golden (test/test_raster_golden.cpp) compare +// les sorties reelles aux sorties de Write pour verifier que ce cas ne se +// produit pas sur les glyphes testes. Si un jour il se produisait, ce serait +// visible immediatement. +inline f64 hypot_f64(f64 a, f64 b) { return sqrt_f64(a * a + b * b); } + +} // namespace proj3 diff --git a/src/proj3/base/mem.hpp b/src/proj3/base/mem.hpp new file mode 100644 index 0000000..fb11e19 --- /dev/null +++ b/src/proj3/base/mem.hpp @@ -0,0 +1,51 @@ +// base/mem.hpp — primitives memoire du projet. +// +// Elles sont volontairement naives : octet par octet, sans deroulage ni SIMD. +// C est le point de depart d une paire d oracle (chantier 4), pas une version +// finale. Une version NEON viendra les remplacer, la version C++ restant la +// reference a vie. +// +// Attention : sur la cible embarquee, ces fonctions ne SONT PAS memcpy/memset. +// Les symboles memcpy/memset que le compilateur peut emettre de lui-meme sont +// fournis separement dans base/cstring.cpp. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3 { + +inline void mem_fill(void* dst, u8 value, usize n) { + u8* p = static_cast(dst); + for (usize i = 0; i < n; ++i) p[i] = value; +} + +inline void mem_copy(void* dst, const void* src, usize n) { + u8* d = static_cast(dst); + const u8* s = static_cast(src); + for (usize i = 0; i < n; ++i) d[i] = s[i]; +} + +// Rend true si les deux zones sont identiques. Pas de tri lexicographique : +// le projet n a besoin que de l egalite, et rendre un ordre inviterait a s en +// servir sur des donnees ou il n a pas de sens. +inline bool mem_equal(const void* a, const void* b, usize n) { + const u8* x = static_cast(a); + const u8* y = static_cast(b); + for (usize i = 0; i < n; ++i) { + if (x[i] != y[i]) return false; + } + return true; +} + +// Indice du premier octet different, ou n si les zones sont identiques. +// Utilise par le diagnostic du harnais d oracle. +inline usize mem_first_diff(const void* a, const void* b, usize n) { + const u8* x = static_cast(a); + const u8* y = static_cast(b); + for (usize i = 0; i < n; ++i) { + if (x[i] != y[i]) return i; + } + return n; +} + +} // namespace proj3 diff --git a/src/proj3/base/sort.hpp b/src/proj3/base/sort.hpp new file mode 100644 index 0000000..e72af45 --- /dev/null +++ b/src/proj3/base/sort.hpp @@ -0,0 +1,53 @@ +// base/sort.hpp — tri en place, sans allocation, a cout pire cas borne. +// +// HEAPSORT, et pas quicksort ni std::sort. +// +// Ce n est pas un detail d implementation, c est le pilier 1 applique a un +// algorithme : le quicksort a un pire cas en O(n^2) atteignable par des +// donnees reelles, et std::sort (introsort) a un cout qui depend de la +// distribution des entrees. Le heapsort est O(n log n) DANS TOUS LES CAS, en +// place, sans recursion, sans memoire auxiliaire. Il est en moyenne un peu +// plus lent que le quicksort ; c est exactement l arbitrage que le projet +// assume : on rejette une construction plus rapide en moyenne mais a variance +// non bornee. +// +// Note sur la stabilite : le heapsort n est pas stable. Aucun usage du projet +// n en depend — le rasterizer trie des intersections par abscisse, et deux +// intersections de meme abscisse delimitent un intervalle de largeur nulle, +// donc invisible quel que soit leur ordre. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3 { + +template +inline void sift_down(T* a, usize start, usize end, Less less) { + usize root = start; + for (;;) { + const usize child = 2 * root + 1; + if (child >= end) break; + usize swap = root; + if (less(a[swap], a[child])) swap = child; + if (child + 1 < end && less(a[swap], a[child + 1])) swap = child + 1; + if (swap == root) return; + const T tmp = a[root]; + a[root] = a[swap]; + a[swap] = tmp; + root = swap; + } +} + +template +inline void heap_sort(T* a, usize n, Less less) { + if (n < 2) return; + for (usize i = n / 2; i-- > 0;) sift_down(a, i, n, less); + for (usize end = n; end-- > 1;) { + const T tmp = a[0]; + a[0] = a[end]; + a[end] = tmp; + sift_down(a, 0, end, less); + } +} + +} // namespace proj3 diff --git a/src/proj3/base/types.hpp b/src/proj3/base/types.hpp new file mode 100644 index 0000000..dfd27ef --- /dev/null +++ b/src/proj3/base/types.hpp @@ -0,0 +1,44 @@ +// base/types.hpp — types entiers de largeur fixe, sans . +// +// Pourquoi ne pas inclure : il est theoriquement disponible en +// freestanding, mais il tire l en-tete systeme de la libc de la +// plateforme, donc un chemin d inclusion qui differe entre la cible embarquee +// et la cible hote. Douze lignes de typedefs suppriment la question. Les +// static_assert ci-dessous garantissent qu on ne se trompe pas. +#pragma once + +namespace proj3 { + +using u8 = unsigned char; +using i8 = signed char; +using u16 = unsigned short; +using i16 = short; +using u32 = unsigned int; +using i32 = int; +using u64 = unsigned long long; +using i64 = long long; + +// Taille et decalage : LP64 des deux cotes (aarch64-linux et x86-64). +using usize = decltype(sizeof(0)); +using iptr = i64; +using uptr = u64; + +static_assert(sizeof(u8) == 1 && sizeof(i8) == 1); +static_assert(sizeof(u16) == 2 && sizeof(i16) == 2); +static_assert(sizeof(u32) == 4 && sizeof(i32) == 4); +static_assert(sizeof(u64) == 8 && sizeof(i64) == 8); +static_assert(sizeof(usize) == 8, "cible LP64 attendue"); +static_assert(sizeof(void*) == 8, "cible 64 bits attendue"); + +// Little-endian suppose partout (AArch64 en mode EL0 Linux, x86-64). +// Le parser TTF lit du big-endian octet par octet, il ne depend donc pas de +// cette hypothese ; mais la composition de framebuffer, si. +// (troncation et endianness sont deux choses differentes : seul le predefini +// du compilateur repond vraiment a la question, en constant de compilation.) +#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) +static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__, "little-endian attendu"); +#else +#error "compilateur sans __BYTE_ORDER__ : verifier l endianness a la main" +#endif + +} // namespace proj3 diff --git a/src/proj3/boot/main.cpp b/src/proj3/boot/main.cpp new file mode 100644 index 0000000..ce0ed29 --- /dev/null +++ b/src/proj3/boot/main.cpp @@ -0,0 +1,45 @@ +// boot/main.cpp — unique fonction C++ appelee par _start. +// +// Ce que fait le binaire embarque a ce stade des chantiers : +// 1. acquiert le bloc memoire et journalise le mode de pages retenu ; +// 2. affiche l occupation des arenes ; +// 3. termine avec le code 0. +// +// Il ne dessine rien, n ouvre aucun peripherique et ne mesure rien : le code +// DRM/KMS, /dev/input et la mesure de latence sont hors perimetre tant que les +// verifications materielles sur le Pixel 3a n ont pas ete faites. +// +// Le code de retour part directement dans exit_group depuis asm/start.S. + +#include "proj3/mem/system.hpp" +#include "proj3/sys/panic.hpp" +#include "proj3/sys/syscalls.hpp" + +using namespace proj3; + +extern "C" int proj3_main(int argc, char** argv) { + (void)argc; + (void)argv; + + err_write("proj3: demarrage (pid="); + const sys::Result pid = sys::getpid(); + err_write_i64(pid.is_ok() ? pid.value() : -1); + err_write(")\n"); + + // Le System est en stockage statique et POD : pas de constructeur a + // executer, donc rien ne depend de .init_array (que _start ne parcourt + // pas, cf. ADR-0001). Il occupe environ 300 octets de .bss. + static mem::System g_mem; + + if (!mem::system_init(g_mem)) { + err_write("proj3: acquisition memoire impossible : les trois chemins\n"); + err_write("proj3: (HUGETLB, THP, pages simples) ont echoue.\n"); + return 1; + } + + mem::log_active_mode(); + mem::system_report(g_mem); + + err_write("proj3: arret normal.\n"); + return 0; +} diff --git a/src/proj3/font/ttf.cpp b/src/proj3/font/ttf.cpp new file mode 100644 index 0000000..955fd15 --- /dev/null +++ b/src/proj3/font/ttf.cpp @@ -0,0 +1,641 @@ +#include "proj3/font/ttf.hpp" + +#include "proj3/base/sort.hpp" + +namespace proj3::font { +namespace { + +// --- Lecture big-endian bornee -------------------------------------------- +// Identique a l original : chaque accesseur verifie ses bornes. Un fichier +// tronque doit produire un echec propre, jamais une lecture hors tampon. + +bool rd_u8(const u8* d, usize n, u32 off, u8& out) { + if (static_cast(off) + 1 > n) return false; + out = d[off]; + return true; +} + +bool rd_u16(const u8* d, usize n, u32 off, u16& out) { + if (static_cast(off) + 2 > n) return false; + out = static_cast((static_cast(d[off]) << 8) | d[off + 1]); + return true; +} + +bool rd_i16(const u8* d, usize n, u32 off, i16& out) { + u16 v = 0; + if (!rd_u16(d, n, off, v)) return false; + out = static_cast(v); + return true; +} + +bool rd_u32(const u8* d, usize n, u32 off, u32& out) { + if (static_cast(off) + 4 > n) return false; + out = (static_cast(d[off]) << 24) | (static_cast(d[off + 1]) << 16) | + (static_cast(d[off + 2]) << 8) | static_cast(d[off + 3]); + return true; +} + +// F2Dot14 : entier signe 16 bits interprete comme un fixe 2.14. +bool rd_f2dot14(const u8* d, usize n, u32 off, f32& out) { + i16 v = 0; + if (!rd_i16(d, n, off, v)) return false; + out = static_cast(v) / 16384.0f; + return true; +} + +// Drapeaux glyf (glyphe simple) +constexpr u8 kOnCurve = 0x01; +constexpr u8 kXShortVector = 0x02; +constexpr u8 kYShortVector = 0x04; +constexpr u8 kRepeatFlag = 0x08; +constexpr u8 kXSameOrPos = 0x10; +constexpr u8 kYSameOrPos = 0x20; + +// Drapeaux glyf (glyphe composite) +constexpr u16 kArg1And2AreWords = 0x0001; +constexpr u16 kArgsAreXyValues = 0x0002; +constexpr u16 kWeHaveAScale = 0x0008; +constexpr u16 kMoreComponents = 0x0020; +constexpr u16 kWeHaveXAndYScale = 0x0040; +constexpr u16 kWeHaveATwoByTwo = 0x0080; + +bool tag_equal(const char* a, const char b[4]) { + return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]; +} + +} // namespace + +// --------------------------------------------------------------------------- + +TtfFont::TableRecord TtfFont::find_table(const char tag[4]) const { + for (u32 i = 0; i < table_count_; ++i) { + if (tag_equal(table_tag_[i], tag)) return table_rec_[i]; + } + return TableRecord{}; +} + +bool TtfFont::load(const u8* data, usize size, mem::Arena& arena, const char*& error) { + error = ""; + data_ = data; + size_ = size; + table_count_ = 0; + + if (size <= 12) { + error = "fichier trop court pour etre un TTF"; + return false; + } + + // En-tete sfnt. Les refus explicites de l original sont conserves mot pour + // mot : ils disent quoi faire, ce qui vaut mieux qu un "signature inconnue". + u32 sfnt = 0; + if (!rd_u32(data_, size_, 0, sfnt)) { + error = "en-tete illisible"; + return false; + } + if (sfnt == 0x4F54544Fu) { + error = "police OpenType/CFF (OTTO) non supportee : il faut un TTF a contours glyf"; + return false; + } + if (sfnt == 0x74746366u) { + error = "collection TrueType (.ttc) : extraire la police voulue en .ttf"; + return false; + } + if (sfnt == 0x774F4646u || sfnt == 0x774F4632u) { + error = "police web (WOFF/WOFF2) non supportee : il faut un .ttf"; + return false; + } + if (sfnt != 0x00010000u && sfnt != 0x74727565u) { + error = "signature sfnt inconnue : ce fichier n est pas un TTF"; + return false; + } + + u16 num_tables = 0; + if (!rd_u16(data_, size_, 4, num_tables)) { + error = "numTables illisible"; + return false; + } + + for (u16 i = 0; i < num_tables; ++i) { + const u32 rec = 12u + 16u * i; + if (static_cast(rec) + 16 > size_) { + error = "repertoire de tables tronque"; + return false; + } + TableRecord tr; + rd_u32(data_, size_, rec + 8, tr.offset); + rd_u32(data_, size_, rec + 12, tr.length); + // Table hors fichier : ignoree plutot que fatale, certaines polices + // ont des longueurs padees legerement fausses. Comportement d origine. + if (tr.offset > size_ || static_cast(tr.offset) + tr.length > size_) continue; + if (table_count_ >= kMaxTables) continue; + tr.present = true; + for (int k = 0; k < 4; ++k) table_tag_[table_count_][k] = static_cast(data_[rec + k]); + table_rec_[table_count_] = tr; + ++table_count_; + } + + const TableRecord glyf = find_table("glyf"); + if (!glyf.present) { + error = "table glyf absente"; + return false; + } + glyf_offset_ = glyf.offset; + glyf_length_ = glyf.length; + + if (!parse_head(error)) return false; + if (!parse_maxp(error)) return false; + if (!parse_hhea_hmtx(error)) return false; + if (!parse_loca(arena, error)) return false; + if (!parse_cmap(arena, error)) return false; + return true; +} + +bool TtfFont::parse_head(const char*& error) { + const TableRecord head = find_table("head"); + if (!head.present || head.length < 54) { + error = "table head absente ou trop courte"; + return false; + } + if (!rd_u16(data_, size_, head.offset + 18, units_per_em_) || units_per_em_ == 0) { + error = "unitsPerEm invalide"; + return false; + } + if (!rd_i16(data_, size_, head.offset + 50, index_to_loc_format_)) { + error = "indexToLocFormat illisible"; + return false; + } + if (index_to_loc_format_ != 0 && index_to_loc_format_ != 1) { + error = "indexToLocFormat inattendu"; + return false; + } + return true; +} + +bool TtfFont::parse_maxp(const char*& error) { + const TableRecord maxp = find_table("maxp"); + if (!maxp.present || maxp.length < 6) { + error = "table maxp absente ou trop courte"; + return false; + } + if (!rd_u16(data_, size_, maxp.offset + 4, num_glyphs_) || num_glyphs_ == 0) { + error = "numGlyphs invalide"; + return false; + } + return true; +} + +bool TtfFont::parse_hhea_hmtx(const char*& error) { + const TableRecord hhea = find_table("hhea"); + const TableRecord hmtx = find_table("hmtx"); + if (!hhea.present || hhea.length < 36 || !hmtx.present) { + error = "tables hhea/hmtx absentes"; + return false; + } + if (!rd_u16(data_, size_, hhea.offset + 34, num_h_metrics_) || num_h_metrics_ == 0) { + error = "numberOfHMetrics invalide"; + return false; + } + rd_i16(data_, size_, hhea.offset + 4, ascender_); + rd_i16(data_, size_, hhea.offset + 6, descender_); + rd_i16(data_, size_, hhea.offset + 8, line_gap_); + hmtx_offset_ = hmtx.offset; + return true; +} + +bool TtfFont::parse_loca(mem::Arena& arena, const char*& error) { + const TableRecord loca = find_table("loca"); + if (!loca.present) { + error = "table loca absente"; + return false; + } + loca_count_ = static_cast(num_glyphs_) + 1u; + loca_ = arena.alloc_array(loca_count_); + for (u32 i = 0; i < loca_count_; ++i) { + u32 rel = 0; + if (index_to_loc_format_ == 0) { + // Format court : les offsets sont stockes divises par deux. + u16 half = 0; + if (!rd_u16(data_, size_, loca.offset + i * 2u, half)) { + error = "loca (format court) tronquee"; + return false; + } + rel = static_cast(half) * 2u; + } else { + if (!rd_u32(data_, size_, loca.offset + i * 4u, rel)) { + error = "loca (format long) tronquee"; + return false; + } + } + loca_[i] = glyf_offset_ + rel; + } + return true; +} + +u32 TtfFont::walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const { + u16 seg_x2 = 0; + if (!rd_u16(data_, size_, off + 6, seg_x2) || seg_x2 == 0) return 0; + const u32 seg_count = seg_x2 / 2u; + + const u32 end_base = off + 14u; + const u32 start_base = end_base + seg_x2 + 2u; // +2 : reservedPad + const u32 delta_base = start_base + seg_x2; + const u32 range_base = delta_base + seg_x2; + + u32 n = 0; + for (u32 s = 0; s < seg_count; ++s) { + u16 end_code = 0, start_code = 0, range_offset = 0; + i16 id_delta = 0; + if (!rd_u16(data_, size_, end_base + s * 2u, end_code) || + !rd_u16(data_, size_, start_base + s * 2u, start_code) || + !rd_i16(data_, size_, delta_base + s * 2u, id_delta) || + !rd_u16(data_, size_, range_base + s * 2u, range_offset)) { + return n; + } + if (start_code > end_code) continue; + for (u32 c = start_code; c <= end_code; ++c) { + if (c == 0xFFFF) continue; // sentinelle de fin de segment + u16 gid = 0; + if (range_offset == 0) { + gid = static_cast((c + static_cast(id_delta)) & 0xFFFF); + } else { + // Adressage indirect : l offset est relatif a la position du + // champ idRangeOffset lui-meme. Particularite du format 4 et + // source d erreur classique. + const u32 idx = range_base + s * 2u + range_offset + (c - start_code) * 2u; + if (!rd_u16(data_, size_, idx, gid)) return n; + if (gid != 0) gid = static_cast((gid + static_cast(id_delta)) & 0xFFFF); + } + if (gid != 0) { + if (out != nullptr) { + if (n >= cap) return n; + out[n] = CmapEntry{c, gid}; + } + ++n; + } + } + } + return n; +} + +u32 TtfFont::walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const { + u32 n_groups = 0; + if (!rd_u32(data_, size_, off + 12, n_groups)) return 0; + u32 n = 0; + for (u32 g = 0; g < n_groups; ++g) { + const u32 rec = off + 16u + 12u * g; + u32 start = 0, end = 0, start_gid = 0; + if (!rd_u32(data_, size_, rec, start) || !rd_u32(data_, size_, rec + 4, end) || + !rd_u32(data_, size_, rec + 8, start_gid)) { + return n; + } + if (end < start || end > 0x10FFFF) continue; + for (u32 c = start; c <= end; ++c) { + const u32 gid = start_gid + (c - start); + if (gid != 0 && gid < num_glyphs_) { + if (out != nullptr) { + if (n >= cap) return n; + out[n] = CmapEntry{c, static_cast(gid)}; + } + ++n; + } + } + } + return n; +} + +bool TtfFont::parse_cmap(mem::Arena& arena, const char*& error) { + const TableRecord cmap = find_table("cmap"); + if (!cmap.present || cmap.length < 4) { + error = "table cmap absente"; + return false; + } + u16 num_sub = 0; + if (!rd_u16(data_, size_, cmap.offset + 2, num_sub)) { + error = "cmap : numTables illisible"; + return false; + } + + // Selection de la sous-table : (3,10) UCS-4, puis (3,1) BMP, puis + // plateforme 0 en repli. Comportement d origine, inchange. + u32 best_offset = 0; + int best_score = -1; + for (u16 i = 0; i < num_sub; ++i) { + const u32 rec = cmap.offset + 4u + 8u * i; + u16 platform = 0, encoding = 0; + u32 sub_off = 0; + if (!rd_u16(data_, size_, rec, platform) || !rd_u16(data_, size_, rec + 2, encoding) || + !rd_u32(data_, size_, rec + 4, sub_off)) { + continue; + } + int score = -1; + if (platform == 3 && encoding == 10) score = 3; + else if (platform == 3 && encoding == 1) score = 2; + else if (platform == 0) score = 1; + if (score > best_score) { + best_score = score; + best_offset = cmap.offset + sub_off; + } + } + if (best_score < 0) { + error = "cmap : aucune sous-table Unicode exploitable"; + return false; + } + + u16 format = 0; + if (!rd_u16(data_, size_, best_offset, format)) { + error = "cmap : format illisible"; + return false; + } + if (format != 4 && format != 12) { + error = "cmap : format non gere (attendu 4 ou 12)"; + return false; + } + + // Deux passes : la premiere compte, la seconde remplit. C est le prix a + // payer pour ne pas avoir de conteneur qui pousse. Le cout est une + // relecture de la sous-table, quelques microsecondes a l init. + const u32 count = (format == 4) ? walk_cmap_format4(best_offset, nullptr, 0) + : walk_cmap_format12(best_offset, nullptr, 0); + if (count == 0) { + error = "cmap : sous-table vide ou tronquee"; + return false; + } + cmap_ = arena.alloc_array(count); + const u32 filled = (format == 4) ? walk_cmap_format4(best_offset, cmap_, count) + : walk_cmap_format12(best_offset, cmap_, count); + cmap_count_ = filled; + + // Tri par (codepoint, gid) puis deduplication sur le codepoint, en gardant + // la premiere entree : c est exactement ce que faisaient std::sort + + // std::unique dans l original. + heap_sort(cmap_, cmap_count_, [](const CmapEntry& a, const CmapEntry& b) { + if (a.codepoint != b.codepoint) return a.codepoint < b.codepoint; + return a.gid < b.gid; + }); + u32 w = 0; + for (u32 r = 0; r < cmap_count_; ++r) { + if (w > 0 && cmap_[w - 1].codepoint == cmap_[r].codepoint) continue; + cmap_[w++] = cmap_[r]; + } + cmap_count_ = w; + return true; +} + +u16 TtfFont::glyph_index_for_codepoint(u32 codepoint) const { + // Recherche binaire, comme l original (lower_bound sur un vector trie). + u32 lo = 0, hi = cmap_count_; + while (lo < hi) { + const u32 mid = lo + (hi - lo) / 2; + if (cmap_[mid].codepoint < codepoint) lo = mid + 1; + else hi = mid; + } + if (lo >= cmap_count_ || cmap_[lo].codepoint != codepoint) return 0; + return cmap_[lo].gid; +} + +// --------------------------------------------------------------------------- + +bool TtfFont::load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const { + out = Glyph{}; + builder.reset(); + if (glyph_index >= num_glyphs_) return false; + + // --- Metriques horizontales (hmtx) --- + // Les glyphes d indice >= numberOfHMetrics partagent la derniere advance ; + // seul leur leftSideBearing est stocke, dans le tableau qui suit. + { + const u16 m = glyph_index < static_cast(num_h_metrics_ - 1) + ? glyph_index + : static_cast(num_h_metrics_ - 1); + u16 adv = 0; + i16 lsb = 0; + rd_u16(data_, size_, hmtx_offset_ + m * 4u, adv); + if (glyph_index < num_h_metrics_) { + rd_i16(data_, size_, hmtx_offset_ + glyph_index * 4u + 2u, lsb); + } else { + const u32 tail = hmtx_offset_ + num_h_metrics_ * 4u; + rd_i16(data_, size_, tail + (glyph_index - num_h_metrics_) * 2u, lsb); + } + out.advance_width = static_cast(adv); + out.left_side_bearing = static_cast(lsb); + } + + const u32 start = loca_[glyph_index]; + const u32 end = loca_[glyph_index + 1]; + out.points = builder.points; + out.contour_end = builder.contour_end; + + if (end <= start) { + // Longueur nulle = glyphe vide (l espace). Les metriques restent + // valides, ce n est pas une erreur. + return true; + } + if (end > glyf_offset_ + glyf_length_ || static_cast(start) + 10 > size_) return false; + + i16 xmin = 0, ymin = 0, xmax = 0, ymax = 0; + i16 n_contours = 0; + if (!rd_i16(data_, size_, start, n_contours) || !rd_i16(data_, size_, start + 2, xmin) || + !rd_i16(data_, size_, start + 4, ymin) || !rd_i16(data_, size_, start + 6, xmax) || + !rd_i16(data_, size_, start + 8, ymax)) { + return false; + } + out.x_min = xmin; + out.y_min = ymin; + out.x_max = xmax; + out.y_max = ymax; + + const bool ok = append_glyph(glyph_index, builder, 0); + out.point_count = builder.point_count; + out.contour_count = builder.contour_count; + return ok; +} + +bool TtfFont::append_glyph(u16 gid, GlyphBuilder& b, int depth) const { + if (gid >= num_glyphs_) return false; + const u32 start = loca_[gid]; + const u32 end = loca_[gid + 1]; + if (end <= start) return true; + if (end > glyf_offset_ + glyf_length_ || static_cast(start) + 10 > size_) return false; + + i16 n_contours = 0; + if (!rd_i16(data_, size_, start, n_contours)) return false; + if (n_contours >= 0) return append_simple_glyph(start, b); + return append_composite_glyph(start, end, b, depth); +} + +bool TtfFont::append_simple_glyph(u32 start, GlyphBuilder& b) const { + i16 n_contours_s = 0; + rd_i16(data_, size_, start, n_contours_s); + if (n_contours_s <= 0) return true; + const u32 n_contours = static_cast(n_contours_s); + if (b.contour_count + n_contours > kMaxGlyphContours) return false; + + u32 p = start + 10; + + // endPtsOfContours : indice du dernier point de chaque contour. + // Ils sont relus depuis le fichier a chaque besoin plutot que stockes + // dans un tableau temporaire : evite une allocation, coute deux lectures. + u16 last_end = 0; + for (u32 i = 0; i < n_contours; ++i) { + if (!rd_u16(data_, size_, p + i * 2u, last_end)) return false; + } + const u32 n_points = static_cast(last_end) + 1u; + if (n_points == 0 || n_points > kMaxGlyphPoints) return false; + if (b.point_count + n_points > kMaxGlyphPoints) return false; + + const u32 end_pts_base = p; + p += n_contours * 2u; + + // On saute les instructions de hinting : elles ne sont pas interpretees. + u16 instr_len = 0; + if (!rd_u16(data_, size_, p, instr_len)) return false; + p += 2u + instr_len; + + // --- Drapeaux, avec run-length (bit kRepeatFlag) --- + const u32 base = b.point_count; + u8* flags = b.flags; + { + u32 nf = 0; + while (nf < n_points) { + u8 f = 0; + if (!rd_u8(data_, size_, p, f)) return false; + ++p; + flags[nf++] = f; + if (f & kRepeatFlag) { + u8 repeat = 0; + if (!rd_u8(data_, size_, p, repeat)) return false; + ++p; + for (u8 r = 0; r < repeat && nf < n_points; ++r) flags[nf++] = f; + } + } + } + + // --- Coordonnees, deltas sur 1 ou 2 octets --- + // Le couple (kXShortVector, kXSameOrPos) encode a la fois la taille et le + // signe du delta : c est le point le plus contre-intuitif du format glyf. + // + // Les accumulateurs restent en i32 comme dans l original, puis sont + // convertis en float. Les coordonnees TrueType sont bornees a +-16384 + // unites de police, donc la conversion est exacte (bien en dessous de + // 2^24) : aucune perte par rapport au code de Write. + { + i32 acc = 0; + for (u32 i = 0; i < n_points; ++i) { + const u8 f = flags[i]; + if (f & kXShortVector) { + u8 d = 0; + if (!rd_u8(data_, size_, p, d)) return false; + ++p; + acc += (f & kXSameOrPos) ? static_cast(d) : -static_cast(d); + } else if (!(f & kXSameOrPos)) { + i16 d = 0; + if (!rd_i16(data_, size_, p, d)) return false; + p += 2; + acc += d; + } // sinon : delta nul, x inchange + b.points[base + i].x = static_cast(acc); + } + } + { + i32 acc = 0; + for (u32 i = 0; i < n_points; ++i) { + const u8 f = flags[i]; + if (f & kYShortVector) { + u8 d = 0; + if (!rd_u8(data_, size_, p, d)) return false; + ++p; + acc += (f & kYSameOrPos) ? static_cast(d) : -static_cast(d); + } else if (!(f & kYSameOrPos)) { + i16 d = 0; + if (!rd_i16(data_, size_, p, d)) return false; + p += 2; + acc += d; + } + b.points[base + i].y = static_cast(acc); + b.points[base + i].on_curve = (f & kOnCurve) != 0; + } + } + + // --- Decoupage en contours --- + u32 first = 0; + for (u32 c = 0; c < n_contours; ++c) { + u16 last = 0; + if (!rd_u16(data_, size_, end_pts_base + c * 2u, last)) return false; + if (last < first || last >= n_points) return false; + b.contour_end[b.contour_count++] = base + last + 1u; + first = last + 1u; + } + b.point_count = base + n_points; + return true; +} + +bool TtfFont::append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const { + if (depth >= kMaxCompositeDepth) return false; + + u32 p = start + 10; + for (;;) { + u16 flags = 0, glyph_index = 0; + if (!rd_u16(data_, size_, p, flags) || !rd_u16(data_, size_, p + 2, glyph_index)) { + return false; + } + p += 4; + + // Arguments : decalage xy, ou indices de points a aligner. Seul le cas + // xy est gere, comme dans l original (l alignement par points est + // rarissime hors polices CJK anciennes). + f32 dx = 0.0f, dy = 0.0f; + if (flags & kArg1And2AreWords) { + i16 a1 = 0, a2 = 0; + if (!rd_i16(data_, size_, p, a1) || !rd_i16(data_, size_, p + 2, a2)) return false; + p += 4; + if (flags & kArgsAreXyValues) { + dx = static_cast(a1); + dy = static_cast(a2); + } + } else { + u8 b1 = 0, b2 = 0; + if (!rd_u8(data_, size_, p, b1) || !rd_u8(data_, size_, p + 1, b2)) return false; + p += 2; + if (flags & kArgsAreXyValues) { + dx = static_cast(static_cast(b1)); + dy = static_cast(static_cast(b2)); + } + } + + f32 a = 1.0f, bb = 0.0f, c = 0.0f, d = 1.0f; + if (flags & kWeHaveAScale) { + if (!rd_f2dot14(data_, size_, p, a)) return false; + d = a; + p += 2; + } else if (flags & kWeHaveXAndYScale) { + if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, d)) { + return false; + } + p += 4; + } else if (flags & kWeHaveATwoByTwo) { + if (!rd_f2dot14(data_, size_, p, a) || !rd_f2dot14(data_, size_, p + 2, bb) || + !rd_f2dot14(data_, size_, p + 4, c) || !rd_f2dot14(data_, size_, p + 6, d)) { + return false; + } + p += 8; + } + + // La composante est ajoutee directement a la suite dans le builder, + // puis transformee sur place. L original construisait un Glyph + // temporaire et copiait ses contours ; ici il n y a pas de copie. + const u32 mark_points = b.point_count; + if (append_glyph(glyph_index, b, depth + 1)) { + for (u32 i = mark_points; i < b.point_count; ++i) { + const f32 x = b.points[i].x, y = b.points[i].y; + b.points[i].x = a * x + c * y + dx; + b.points[i].y = bb * x + d * y + dy; + } + } + + if (!(flags & kMoreComponents)) break; + if (p >= end) break; + } + return true; +} + +} // namespace proj3::font diff --git a/src/proj3/font/ttf.hpp b/src/proj3/font/ttf.hpp new file mode 100644 index 0000000..5f95558 --- /dev/null +++ b/src/proj3/font/ttf.hpp @@ -0,0 +1,181 @@ +// font/ttf.hpp — parser TTF, porte depuis Gastinel Write (src/font/ttf.h). +// +// SOUS-ENSEMBLE STRICT, inchange par rapport a l original : +// head : unitsPerEm, indexToLocFormat +// maxp : numGlyphs +// cmap : Unicode -> index de glyphe (formats 4 et 12 uniquement) +// loca : offsets dans glyf +// glyf : contours quadratiques (simples et composites) +// hmtx : advanceWidth / leftSideBearing (avec hhea) +// +// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE (cf. README) : +// pas de kern / GPOS -> aucun crenage +// pas de fpgm/prep/cvt -> aucun hinting, instructions ignorees +// pas de CFF / CFF2 -> les polices PostScript sont refusees +// pas de VORG / vmtx -> pas d ecriture verticale +// Ces choix sont volontaires et ne doivent pas etre "corriges" dans ce +// chantier. +// +// CE QUI CHANGE PAR RAPPORT A L ORIGINAL, et pourquoi : +// 1. std::vector / std::string ont disparu. Rien n alloue : l appelant +// fournit les arenes. Le garde-fou du chantier 3 tue le processus si une +// allocation cachee subsistait. +// 2. Le fichier n est plus copie. load() prend un tampon deja en memoire, +// dont l appelant garde la propriete et qui doit rester valide aussi +// longtemps que la police. L original copiait tout le fichier dans un +// vector ; ici c est l arene de l appelant qui le detient. +// 3. Les messages d erreur sont des chaines litterales, pas des std::string +// concatenees. On perd le nom du fichier dans le message ; l appelant l a. +// 4. La lecture de fichier n est plus dans cette classe (elle utilisait +// fopen). Elle est dans io/file.hpp, avec une implementation par cible. +// +// ENDIANNESS : le format TrueType est big-endian. Le parser lit octet par +// octet et reconstruit les valeurs a la main, exactement comme l original : +// il est donc insensible a l endianness de la machine. Ce point ne change pas +// entre x86 Windows et AArch64 Linux. (Ce n est PAS vrai de la composition +// vers le framebuffer : cf. render/compose.hpp.) +#pragma once + +#include "proj3/base/math.hpp" +#include "proj3/base/types.hpp" +#include "proj3/mem/arena.hpp" + +namespace proj3::font { + +// Un point de contour, en unites de police. +// on_curve distingue les points d ancrage des points de controle quadratiques +// (TrueType n a pas de cubiques). +struct GlyphPoint { + f32 x = 0.0f; + f32 y = 0.0f; + bool on_curve = false; +}; + +// Bornes reprises de l original : n_points > 10000 y etait deja un refus. +// kMaxGlyphContours est nouveau — l original s appuyait sur la croissance du +// vector. 256 contours est deja bien au-dela de tout glyphe reel (le glyphe +// le plus charge d Inter en compte moins de 40). +inline constexpr u32 kMaxGlyphPoints = 10000; +inline constexpr u32 kMaxGlyphContours = 256; +inline constexpr int kMaxCompositeDepth = 5; + +// Tampon de construction d un glyphe. Alloue UNE FOIS dans une arene, puis +// reutilise pour tous les glyphes. C est ce qui remplace la croissance des +// vector de l original. +struct GlyphBuilder { + GlyphPoint* points = nullptr; + u32* contour_end = nullptr; // indice de fin exclusif de chaque contour + // Tampon de drapeaux glyf. Il vit dans le builder et non sur la pile : + // 10000 octets de pile seraient deja discutables, et la pile d un + // processus sans libc n a pas de garde-page automatique. + u8* flags = nullptr; + u32 point_count = 0; + u32 contour_count = 0; + + void init(mem::Arena& a) { + points = a.alloc_array(kMaxGlyphPoints); + contour_end = a.alloc_array(kMaxGlyphContours); + flags = a.alloc_array(kMaxGlyphPoints); + reset(); + } + void reset() { + point_count = 0; + contour_count = 0; + } +}; + +// Un glyphe decode. Les pointeurs visent le GlyphBuilder : la duree de vie +// d un Glyph est celle du prochain appel a load_glyph. +struct Glyph { + const GlyphPoint* points = nullptr; + const u32* contour_end = nullptr; + u32 point_count = 0; + u32 contour_count = 0; + + f32 x_min = 0.0f, y_min = 0.0f, x_max = 0.0f, y_max = 0.0f; + f32 advance_width = 0.0f; + f32 left_side_bearing = 0.0f; + + bool empty() const { return contour_count == 0; } + + // Bornes du contour i dans points[]. + u32 contour_begin(u32 i) const { return i == 0 ? 0u : contour_end[i - 1]; } + u32 contour_size(u32 i) const { return contour_end[i] - contour_begin(i); } +}; + +class TtfFont { +public: + // `data` doit rester valide tant que la police est utilisee : rien n est + // copie. `arena` sert a loca et cmap, alloues une fois pour toutes. + // En cas d echec, `error` recoit un litteral (jamais nullptr). + bool load(const u8* data, usize size, mem::Arena& arena, const char*& error); + + u16 glyph_index_for_codepoint(u32 codepoint) const; + + // Decode les contours d un glyphe dans `builder`. `out` pointe dedans. + bool load_glyph(u16 glyph_index, GlyphBuilder& builder, Glyph& out) const; + + u16 units_per_em() const { return units_per_em_; } + i16 ascender() const { return ascender_; } + i16 descender() const { return descender_; } + i16 line_gap() const { return line_gap_; } + u16 num_glyphs() const { return num_glyphs_; } + u32 cmap_size() const { return cmap_count_; } + +private: + struct TableRecord { + u32 offset = 0; + u32 length = 0; + bool present = false; + }; + struct CmapEntry { + u32 codepoint; + u16 gid; + }; + + TableRecord find_table(const char tag[4]) const; + + bool parse_head(const char*& error); + bool parse_maxp(const char*& error); + bool parse_hhea_hmtx(const char*& error); + bool parse_loca(mem::Arena& arena, const char*& error); + bool parse_cmap(mem::Arena& arena, const char*& error); + + // Deux passes : compte puis remplit. `out` nul = passe de comptage. + u32 walk_cmap_format4(u32 off, CmapEntry* out, u32 cap) const; + u32 walk_cmap_format12(u32 off, CmapEntry* out, u32 cap) const; + + bool append_simple_glyph(u32 start, GlyphBuilder& b) const; + bool append_composite_glyph(u32 start, u32 end, GlyphBuilder& b, int depth) const; + bool append_glyph(u16 gid, GlyphBuilder& b, int depth) const; + + const u8* data_ = nullptr; + usize size_ = 0; + + // Repertoire de tables : tableau fixe. 64 tables est deja plus du double + // de ce qu une police reelle expose. + static constexpr u32 kMaxTables = 64; + char table_tag_[kMaxTables][4] = {}; + TableRecord table_rec_[kMaxTables] = {}; + u32 table_count_ = 0; + + u16 units_per_em_ = 1000; + i16 index_to_loc_format_ = 0; + u16 num_glyphs_ = 0; + u16 num_h_metrics_ = 0; + i16 ascender_ = 0; + i16 descender_ = 0; + i16 line_gap_ = 0; + + u32 glyf_offset_ = 0; + u32 glyf_length_ = 0; + u32 hmtx_offset_ = 0; + + u32* loca_ = nullptr; // num_glyphs + 1 offsets absolus + u32 loca_count_ = 0; + + CmapEntry* cmap_ = nullptr; + u32 cmap_count_ = 0; +}; + +} // namespace proj3::font diff --git a/src/proj3/mem/arena.cpp b/src/proj3/mem/arena.cpp new file mode 100644 index 0000000..b10ab15 --- /dev/null +++ b/src/proj3/mem/arena.cpp @@ -0,0 +1,71 @@ +#include "proj3/mem/arena.hpp" + +#include "proj3/sys/panic.hpp" + +namespace proj3::mem { +namespace { + +constexpr bool is_power_of_two(usize v) { return v != 0 && (v & (v - 1)) == 0; } + +} // namespace + +void Arena::init(const char* name, u8* base, usize capacity) { + name_ = name; + base_ = base; + capacity_ = capacity; + used_ = 0; + peak_ = 0; +} + +void* Arena::try_alloc(usize size, usize align) { + if (base_ == nullptr) return nullptr; + if (!is_power_of_two(align)) return nullptr; + + // Alignement calcule sur l offset, pas sur l adresse : la base d une arene + // est toujours alignee sur une page (donc sur tout ce qui nous interesse), + // et travailler en offset garde le calcul independant de l adresse reelle. + // C est ce qui rend le comportement identique entre l hote et la cible. + const usize aligned = (used_ + (align - 1)) & ~(align - 1); + + // Debordement arithmetique verifie avant le test de capacite : sur une + // taille absurde, aligned + size pourrait reboucler et passer le test. + if (aligned < used_) return nullptr; + if (size > capacity_ - aligned) return nullptr; + + u8* p = base_ + aligned; + used_ = aligned + size; + if (used_ > peak_) peak_ = used_; + return p; +} + +void* Arena::alloc(usize size, usize align) { + void* p = try_alloc(size, align); + if (p != nullptr) return p; + + // Diagnostic exploitable : on veut savoir QUELLE arene, combien elle a, + // combien on demandait. Sans ces trois nombres, le message ne sert a rien. + err_write("proj3: PANIQUE: debordement d arene '"); + err_write(name_); + err_write("' : demande="); + err_write_i64(static_cast(size)); + err_write(" align="); + err_write_i64(static_cast(align)); + err_write(" occupe="); + err_write_i64(static_cast(used_)); + err_write(" capacite="); + err_write_i64(static_cast(capacity_)); + err_write("\n"); + err_write(" Un debordement d arene est un defaut de conception, pas un cas\n"); + err_write(" a gerer : corriger le calcul dans mem/layout.hpp.\n"); + panic("debordement d arene"); +} + +void Arena::rewind_to(usize m) { + if (m > used_) { + panic_v("rewind_to au-dela de la position courante", "marque", + static_cast(m)); + } + used_ = m; +} + +} // namespace proj3::mem diff --git a/src/proj3/mem/arena.hpp b/src/proj3/mem/arena.hpp new file mode 100644 index 0000000..b4e5c9b --- /dev/null +++ b/src/proj3/mem/arena.hpp @@ -0,0 +1,76 @@ +// mem/arena.hpp — allocateur lineaire (bump allocator). +// +// Regles, non negociables : +// - allocation = avance de pointeur, avec alignement ; +// - aucune liberation individuelle ; un reset global par arene ; +// - un debordement est une PANIQUE, jamais un agrandissement. +// +// Le dernier point est le plus important : un debordement d arene signifie que +// le calcul de mem/layout.hpp est faux. Agrandir masquerait l erreur et +// reintroduirait une allocation apres l init, donc une latence non bornee. +// On veut que ca casse, fort, au premier essai, avec le nom de l arene. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3::mem { + +class Arena { +public: + // Une arene non initialisee est inutilisable : toute allocation panique. + constexpr Arena() = default; + + void init(const char* name, u8* base, usize capacity); + + // Alloue `size` octets alignes sur `align` (puissance de deux). + // Ne rend jamais nullptr : soit ca reussit, soit ca panique. + void* alloc(usize size, usize align); + + // Allocation typee. L alignement vient du type. La memoire N EST PAS + // construite : Arena ne connait pas les constructeurs, et le projet + // n utilise que des types trivialement constructibles. + template + T* alloc_array(usize count) { + return static_cast(alloc(count * sizeof(T), alignof(T))); + } + + template + T* alloc_one() { + return static_cast(alloc(sizeof(T), alignof(T))); + } + + // Version qui rend nullptr au lieu de paniquer. Reservee aux cas ou + // l appelant a un vrai chemin de repli. Il n y en a aucun aujourd hui ; + // elle existe pour que le harnais de test puisse verifier la borne sans + // se faire tuer. + void* try_alloc(usize size, usize align); + + // Marque de position, pour un rembobinage local (motif "scratch dans le + // scratch"). Ce n est PAS une liberation : rembobiner invalide tout ce qui + // a ete alloue apres la marque. + usize mark() const { return used_; } + void rewind_to(usize m); + + void reset() { used_ = 0; } + + const char* name() const { return name_; } + usize capacity() const { return capacity_; } + usize used() const { return used_; } + usize remaining() const { return capacity_ - used_; } + u8* base() const { return base_; } + + // Plus haute occupation atteinte depuis l init. C est la seule metrique + // qui permette de dire si une taille de mem/layout.hpp est juste ou + // fantaisiste. Elle est mise a jour a chaque allocation, cout : une + // comparaison. + usize peak() const { return peak_; } + +private: + const char* name_ = ""; + u8* base_ = nullptr; + usize capacity_ = 0; + usize used_ = 0; + usize peak_ = 0; +}; + +} // namespace proj3::mem diff --git a/src/proj3/mem/layout.hpp b/src/proj3/mem/layout.hpp new file mode 100644 index 0000000..4ff3a25 --- /dev/null +++ b/src/proj3/mem/layout.hpp @@ -0,0 +1,117 @@ +// mem/layout.hpp — budget memoire du projet, en constexpr. +// +// DIMENSIONNE POUR LE PIXEL 3A : 4 Go de RAM, ecran 1080x2220. +// PAS pour la cible 12 Go. Cf. doc/memoire.md, section "Passage a la cible +// 12 Go", pour la liste de ce qu il faudra revalider. +// +// Chaque taille ci-dessous est un CALCUL, pas un chiffre rond. Si un calcul +// est faux, il doit etre corrige ici, pas contourne par une marge. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3::mem { + +inline constexpr usize kKiB = 1024; +inline constexpr usize kMiB = 1024 * kKiB; + +// Granularite de page classique sur arm64 avec un noyau Android stock +// (CONFIG_ARM64_4K_PAGES). Les noyaux 16K existent (certains Pixel recents) : +// si la cible en utilisait un, l alignement ci-dessous resterait valide, il +// serait seulement plus grossier que necessaire. +inline constexpr usize kPageSize = 4 * kKiB; + +// Taille de huge page visee. 2 Mo est la seule taille garantie presente sur +// arm64 en 4K pages (PMD-level). 1 Go (PUD) existe mais n est pas active sur +// un noyau mobile. +inline constexpr usize kHugePageSize = 2 * kMiB; + +inline constexpr usize align_up(usize v, usize a) { return (v + (a - 1)) & ~(a - 1); } + +// --- Ecran ---------------------------------------------------------------- +inline constexpr usize kScreenWidth = 1080; +inline constexpr usize kScreenHeight = 2220; +inline constexpr usize kBytesPerPixel = 4; // XRGB8888, format de scanout DRM + +// --- 1. Scanout ----------------------------------------------------------- +// Calcul : 1080 * 2220 * 4 = 9 590 400 octets par tampon. +// Deux tampons : double buffering. Pas trois : un triple buffering ajoute une +// image entiere de latence, ce qui est exactement ce que le projet combat. +// Chaque tampon est aligne sur une page pour pouvoir etre passe tel quel a un +// import DRM ulterieur. +inline constexpr usize kScanoutOneRaw = kScreenWidth * kScreenHeight * kBytesPerPixel; +inline constexpr usize kScanoutOne = align_up(kScanoutOneRaw, kPageSize); +inline constexpr usize kScanoutBuffers = 2; +inline constexpr usize kScanoutBytes = kScanoutOne * kScanoutBuffers; +static_assert(kScanoutOneRaw == 9590400); + +// --- 2. Geometrie / contours du rasterizer -------------------------------- +// Une arete de balayage occupe 20 octets (4 float + 1 int32). +// Pire cas raisonne : un glyphe complexe (ideogramme, ligature dense) compte +// jusqu a ~600 points de contour. A 64 px/em, une courbe quadratique mesure au +// plus ~64 px de polygone de controle, donc au plus ceil(64/1.5) = 43 +// subdivisions, plafonnees a 64 par le rasterizer. Majorant : 600 * 64 = 38400 +// aretes, soit 768 000 octets. +// On prend 2 Mo, ce qui laisse la place pour rasteriser un trace d interface +// (bordures, coins arrondis) dans la meme passe sans reset intermediaire. +inline constexpr usize kEdgeBytes = 20; +inline constexpr usize kGeometryBytes = 2 * kMiB; +static_assert(kGeometryBytes / kEdgeBytes > 38400 * 2, "marge geometrie insuffisante"); + +// --- 3. Atlas de glyphes -------------------------------------------------- +// Couverture 8 bits, 1 octet par pixel. +// Trois corps prevus : 16 px (texte), 24 px (interface), 32 px (titres). +// Une cellule mesure (corps + 2) au carre, les 2 px absorbant la marge d un +// pixel que le rasterizer ajoute de chaque cote. +// 16 -> 18*18 = 324 +// 24 -> 26*26 = 676 +// 32 -> 34*34 = 1156 +// total par glyphe = 2156 octets +// Jeu couvert : Latin-1 complet plus ponctuation, soit 256 glyphes. +// 256 * 2156 = 551 936 octets. +// On prend 2 Mo, soit un facteur 3,8 : de quoi ajouter un quatrieme corps ou +// une variante grasse sans redimensionner l arene. +inline constexpr usize kAtlasGlyphSlots = 256; +inline constexpr usize kAtlasBytesPerGlyph = 18 * 18 + 26 * 26 + 34 * 34; +inline constexpr usize kAtlasBytes = 2 * kMiB; +static_assert(kAtlasBytesPerGlyph == 2156); +static_assert(kAtlasBytes > kAtlasGlyphSlots * kAtlasBytesPerGlyph * 3); + +// --- 4. Evenements d entree ----------------------------------------------- +// Un evenement d entree normalise fait 32 octets (horodatage 64 bits, type, +// code, valeur, identifiant de contact, remplissage). +// Un ecran tactile rapporte au plus ~200 evenements par seconde et par point +// de contact, dix points simultanes au maximum : 2000 evenements/seconde. +// Un tampon de 4096 evenements couvre donc plus de deux secondes d entree en +// rafale — largement au-dela du delai maximal entre deux images. +// 4096 * 32 = 131 072 octets. +inline constexpr usize kInputEventBytes = 32; +inline constexpr usize kInputEventSlots = 4096; +inline constexpr usize kInputBytes = kInputEventBytes * kInputEventSlots; +static_assert(kInputBytes == 128 * kKiB); + +// --- 5. Scratch de frame -------------------------------------------------- +// Remise a zero a chaque image. Contient les intersections de balayage, les +// listes de rectangles sales, les tampons temporaires de composition. +// Majorant pour les intersections : une ligne de balayage peut etre traversee +// par toutes les aretes du glyphe, soit 38400 croisements de 8 octets = +// 307 200 octets. Le reste est de la composition par tuiles. +// 2 Mo, avec le meme raisonnement de marge que la geometrie. +inline constexpr usize kFrameScratchBytes = 2 * kMiB; + +// --- Total ---------------------------------------------------------------- +inline constexpr usize kArenaTotalRaw = + kScanoutBytes + kGeometryBytes + kAtlasBytes + kInputBytes + kFrameScratchBytes; + +// On demande au noyau un bloc arrondi au multiple superieur de 2 Mo, sans quoi +// MAP_HUGETLB echoue (le noyau exige une longueur multiple de la taille de +// huge page). Le reliquat n est pas perdu : il est expose comme reserve. +inline constexpr usize kArenaTotal = align_up(kArenaTotalRaw, kHugePageSize); +inline constexpr usize kReserveBytes = kArenaTotal - kArenaTotalRaw; + +static_assert(kArenaTotal % kHugePageSize == 0); +// Verification d ordre de grandeur : le budget total doit rester tres en +// dessous du pour-cent de la RAM du Pixel 3a. 4 Go = 4 294 967 296 octets. +static_assert(kArenaTotal < 4294967296ull / 64, "budget memoire hors de proportion"); + +} // namespace proj3::mem diff --git a/src/proj3/mem/new_guard.cpp b/src/proj3/mem/new_guard.cpp new file mode 100644 index 0000000..83dc3ba --- /dev/null +++ b/src/proj3/mem/new_guard.cpp @@ -0,0 +1,119 @@ +// mem/new_guard.cpp — GARDE-FOU DU PILIER 2. +// +// Redefinit les operateurs d allocation globaux pour qu ils tuent le processus +// immediatement, avec un message identifiable. +// +// Ce n est pas un test : c est un filet permanent. Toute allocation dynamique +// cachee — un std::vector oublie dans du code porte, une lambda capturee par +// valeur qui deborde du stockage local, un conteneur d une bibliotheque tierce +// — devient un plantage immediat et localisable au lieu d une degradation +// silencieuse de la latence. +// +// COMMENT LOCALISER LE COUPABLE quand ce message apparait : +// 1. Le message donne la taille demandee. +// 2. Poser un point d arret sur `operator new` (le symbole existe, il n est +// pas inline) et remonter la pile. Deux images suffisent en general. +// 3. Sur la cible : le processus s arrete avec le code 71, distinct du 70 +// de panic(), pour qu un script sache que c est une allocation et pas +// autre chose. +// +// CE QUE LE GARDE-FOU N ATTRAPE PAS, et c est important de le savoir : +// - malloc / calloc / realloc / free appeles directement. Ce sont des +// fonctions C, sans rapport avec operator new. Sur la cible embarquee la +// question ne se pose pas (pas de libc, le lien echouerait). Sur l hote, +// page_source_host.cpp les utilise deliberement. +// - les allocations faites par le noyau (pile, mmap). +// - les VLA et alloca, qui prennent sur la pile. +// Le perimetre est donc exactement : "aucun new C++ nulle part". C est ce +// qu on veut verifier. +// +// EMPLACEMENT DANS LA CONSTRUCTION : ce fichier est une bibliotheque separee +// (proj3_newguard). On ne le lie que dans les executables qui pretendent ne +// rien allouer. Le lier partout casserait tout outil qui utilise la STL de +// l hote — ce qui est precisement le comportement recherche, mais il faut le +// choisir explicitement, executable par executable. + +#include "proj3/base/types.hpp" +#include "proj3/sys/panic.hpp" + +#if PROJ3_EMBEDDED +#include "proj3/sys/syscalls.hpp" +// Sur la cible embarquee il n y a pas d en-tete a inclure : la +// bibliotheque standard n est pas installee pour le triplet croise. On declare +// donc le seul type dont on a besoin, avec exactement la definition qu impose +// le standard ([support.types], enumeration a portee de type sous-jacent +// size_t). Le compilateur reconnait ce type par son nom qualifie. +namespace std { +enum class align_val_t : proj3::usize {}; +} +#else +#include +#include +#endif + +namespace { + +[[noreturn]] void trap_allocation(const char* which, proj3::usize size) { + proj3::err_write("proj3: ALLOCATION INTERDITE: "); + proj3::err_write(which); + proj3::err_write(" taille="); + proj3::err_write_i64(static_cast(size)); + proj3::err_write("\n"); + proj3::err_write( + " Le projet n alloue rien apres l init. Tout passe par une arene\n" + " (mem/arena.hpp). Poser un point d arret sur operator new et\n" + " remonter la pile pour trouver l appelant.\n"); +#if PROJ3_EMBEDDED + proj3::sys::exit_group(71); +#else + std::_Exit(71); +#endif +} + +[[noreturn]] void trap_free(const char* which) { + proj3::err_write("proj3: LIBERATION INTERDITE: "); + proj3::err_write(which); + proj3::err_write("\n"); + proj3::err_write( + " Une arene ne libere pas individuellement. Atteindre ce point\n" + " signifie qu un objet a ete alloue par new quelque part.\n"); +#if PROJ3_EMBEDDED + proj3::sys::exit_group(71); +#else + std::_Exit(71); +#endif +} + +} // namespace + +// Les signatures doivent correspondre exactement a celles du standard, sinon +// on ne remplace pas l operateur, on en ajoute un autre. On couvre les formes +// de base et les formes alignees (C++17), que le compilateur choisit tout seul +// pour un type sur-aligne — cas typique d un tampon NEON. + +void* operator new(proj3::usize size) { trap_allocation("operator new", size); } +void* operator new[](proj3::usize size) { trap_allocation("operator new[]", size); } + +void* operator new(proj3::usize size, std::align_val_t) { + trap_allocation("operator new (aligne)", size); +} +void* operator new[](proj3::usize size, std::align_val_t) { + trap_allocation("operator new[] (aligne)", size); +} + +void operator delete(void*) noexcept { trap_free("operator delete"); } +void operator delete[](void*) noexcept { trap_free("operator delete[]"); } +void operator delete(void*, proj3::usize) noexcept { trap_free("operator delete (dimensionne)"); } +void operator delete[](void*, proj3::usize) noexcept { + trap_free("operator delete[] (dimensionne)"); +} +void operator delete(void*, std::align_val_t) noexcept { trap_free("operator delete (aligne)"); } +void operator delete[](void*, std::align_val_t) noexcept { + trap_free("operator delete[] (aligne)"); +} +void operator delete(void*, proj3::usize, std::align_val_t) noexcept { + trap_free("operator delete (dimensionne aligne)"); +} +void operator delete[](void*, proj3::usize, std::align_val_t) noexcept { + trap_free("operator delete[] (dimensionne aligne)"); +} diff --git a/src/proj3/mem/page_source.hpp b/src/proj3/mem/page_source.hpp new file mode 100644 index 0000000..09e5060 --- /dev/null +++ b/src/proj3/mem/page_source.hpp @@ -0,0 +1,85 @@ +// mem/page_source.hpp — acquisition des pages, avec repli detecte au runtime. +// +// UN SEUL BINAIRE, TROIS CHEMINS, choisis a l execution : +// +// 1. mmap(MAP_HUGETLB | MAP_HUGE_2MB) -> HugeMode::Hugetlb2MB +// 2. mmap classique + madvise(MADV_HUGEPAGE) -> HugeMode::TransparentHuge +// 3. mmap classique seul -> HugeMode::PlainPages +// +// Meme esprit que le repli OpenGL/GDI de Gastinel Write : on ne compile pas +// deux binaires, on ne demande pas a l utilisateur, on essaie dans l ordre et +// on journalise ce qui a marche. +// +// CES TROIS MODES N ONT PAS LES MEMES PROPRIETES DE DETERMINISME. +// C est le point central de ce fichier, pas une note de bas de page : +// +// Hugetlb2MB Les pages sont reservees d avance dans le pool hugetlbfs. +// Elles ne sont ni deplacees, ni fusionnees, ni recuperees. +// Une entree de TLB couvre 2 Mo. Les mesures de latence +// faites dans ce mode sont valides. +// +// TransparentHuge Le noyau PEUT promouvoir la region en huge pages, ou pas, +// et il le fait par un fil de fond (khugepaged) dont +// l ordonnancement nous echappe. Une promotion ou une +// scission peut se produire PENDANT une mesure. Toute +// mesure de latence faite dans ce mode porte une barre +// d erreur inconnue et doit etre annotee comme telle. +// +// PlainPages Pages de 4 Ko. Le comportement est previsible mais le +// nombre d entrees de TLB necessaires pour couvrir le +// scanout (9,6 Mo, soit ~2342 pages) depasse la TLB L2 d un +// Cortex-A75. Les manques de TLB sont alors une source de +// variance mesurable. Le mode est correct, pas rapide. +// +// C est pourquoi active_mode() est expose dans l API : tout code qui produit +// une mesure doit pouvoir l estampiller. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3::mem { + +enum class HugeMode : u32 { + Uninitialized = 0, + Hugetlb2MB, + TransparentHuge, + PlainPages, + // Cible hote uniquement : memoire fournie par la libc de l hote. Aucune + // garantie d aucune sorte. Presente pour que le harnais puisse tourner + // sur la machine de dev, et pour qu il soit IMPOSSIBLE de confondre une + // mesure faite ici avec une mesure faite sur la cible. + HostEmulated, +}; + +struct PageBlock { + u8* base = nullptr; + usize size = 0; + HugeMode mode = HugeMode::Uninitialized; +}; + +// Nom lisible, pour la journalisation. Jamais nullptr. +const char* huge_mode_name(HugeMode m); + +// true si le mode donne autorise a publier une mesure de latence sans +// avertissement. Un seul mode repond true. +constexpr bool mode_is_deterministic(HugeMode m) { return m == HugeMode::Hugetlb2MB; } + +// Acquiert `size` octets. `size` doit etre un multiple de 2 Mo (exige par +// MAP_HUGETLB ; on impose la meme contrainte aux trois chemins pour que le +// mode retenu ne change pas la disposition memoire). +// Rend false uniquement si les TROIS chemins ont echoue. +bool page_acquire(usize size, PageBlock& out); + +// Rend les pages. N est appele qu en fin de processus, et meme la c est +// superflu (le noyau nettoie). Existe pour que le harnais hote puisse +// enchainer plusieurs acquisitions sans fuir. +void page_release(PageBlock& block); + +// Mode effectivement retenu par la derniere acquisition reussie. +// Interrogeable par le programme, comme demande. +HugeMode active_mode(); + +// Journalise sur la sortie d erreur le mode retenu et ses implications. +void log_active_mode(); + +} // namespace proj3::mem diff --git a/src/proj3/mem/page_source_host.cpp b/src/proj3/mem/page_source_host.cpp new file mode 100644 index 0000000..54f6dc9 --- /dev/null +++ b/src/proj3/mem/page_source_host.cpp @@ -0,0 +1,91 @@ +// mem/page_source_host.cpp — acquisition des pages sur la machine de dev. +// +// CIBLE HOTE UNIQUEMENT. Utilise malloc, ce qui serait inacceptable sur la +// cible embarquee. C est l asymetrie assumee de l ADR-0001. +// +// Le mode rendu est toujours HugeMode::HostEmulated, precisement pour qu il +// soit impossible de prendre une mesure faite ici pour une mesure faite sur +// le telephone. Ce n est pas un detail cosmetique : c est la seule protection +// contre la publication d un chiffre obtenu sur un x86 de bureau. +// +// Le malloc utilise ici est appele AVANT que le garde-fou d allocation ne +// puisse intervenir, et il passe par malloc et non par operator new : les deux +// mecanismes sont distincts, le garde-fou n intercepte que operator new. +// C est voulu. Cf. mem/new_guard.cpp, section "Ce que le garde-fou n attrape +// pas". +#include "proj3/mem/page_source.hpp" + +#include + +#include "proj3/mem/layout.hpp" +#include "proj3/sys/panic.hpp" + +namespace proj3::mem { +namespace { + +HugeMode g_active = HugeMode::Uninitialized; + +// On garde le pointeur brut rendu par malloc pour pouvoir le liberer, puisque +// la base publiee est alignee et donc potentiellement decalee. +void* g_raw = nullptr; + +} // namespace + +const char* huge_mode_name(HugeMode m) { + switch (m) { + case HugeMode::Hugetlb2MB: return "HUGETLB-2MB"; + case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE"; + case HugeMode::PlainPages: return "PAGES-4K"; + case HugeMode::HostEmulated: return "HOTE-EMULE"; + case HugeMode::Uninitialized: break; + } + return "NON-INITIALISE"; +} + +bool page_acquire(usize size, PageBlock& out) { + out = PageBlock{}; + if (size == 0 || (size % kHugePageSize) != 0) { + panic_v("page_acquire : taille non multiple de 2 Mo", "taille", + static_cast(size)); + } + if (g_raw != nullptr) { + panic("page_acquire hote : une seule acquisition a la fois"); + } + + // Alignement manuel sur 2 Mo : on veut que la disposition memoire vue par + // les arenes soit la meme que sur la cible, sinon un bug d alignement ne + // se manifesterait que sur le telephone. + void* raw = std::malloc(size + kHugePageSize); + if (raw == nullptr) return false; + g_raw = raw; + + const uptr addr = reinterpret_cast(raw); + const uptr aligned = (addr + (kHugePageSize - 1)) & ~static_cast(kHugePageSize - 1); + + out.base = reinterpret_cast(aligned); + out.size = size; + out.mode = HugeMode::HostEmulated; + g_active = out.mode; + return true; +} + +void page_release(PageBlock& block) { + if (g_raw != nullptr) { + std::free(g_raw); + g_raw = nullptr; + } + block = PageBlock{}; +} + +HugeMode active_mode() { return g_active; } + +void log_active_mode() { + err_write("proj3: memoire : mode retenu = "); + err_write(huge_mode_name(g_active)); + err_write("\n"); + err_write("proj3: memoire : CIBLE HOTE. Aucune propriete de determinisme.\n"); + err_write("proj3: memoire : ce mode sert a valider la CORRECTION, jamais\n"); + err_write("proj3: memoire : la latence. Ne publier aucun chiffre d ici.\n"); +} + +} // namespace proj3::mem diff --git a/src/proj3/mem/page_source_linux.cpp b/src/proj3/mem/page_source_linux.cpp new file mode 100644 index 0000000..2ce59ef --- /dev/null +++ b/src/proj3/mem/page_source_linux.cpp @@ -0,0 +1,114 @@ +// mem/page_source_linux.cpp — acquisition des pages sur la cible embarquee. +// +// N utilise que nos wrappers syscall. Aucune libc. +#include "proj3/mem/page_source.hpp" + +#include "proj3/mem/layout.hpp" +#include "proj3/sys/panic.hpp" +#include "proj3/sys/syscalls.hpp" +#include "proj3/sys/uapi.hpp" + +namespace proj3::mem { +namespace { + +// Etat global mutable : une seule variable, un enum, ecrite une fois a l init +// et lue ensuite. C est la seule entorse a la regle "pas de .data mutable", +// et elle est ici parce que le mode retenu doit rester interrogeable par tout +// le programme sans etre passe de main en main. +HugeMode g_active = HugeMode::Uninitialized; + +sys::Result map_anon(usize size, i32 extra_flags) { + const i32 prot = sys::PROT_READ | sys::PROT_WRITE; + const i32 flags = sys::MAP_PRIVATE | sys::MAP_ANONYMOUS | extra_flags; + return sys::mmap(nullptr, size, prot, flags, -1, 0); +} + +} // namespace + +const char* huge_mode_name(HugeMode m) { + switch (m) { + case HugeMode::Hugetlb2MB: return "HUGETLB-2MB"; + case HugeMode::TransparentHuge: return "THP-MADV_HUGEPAGE"; + case HugeMode::PlainPages: return "PAGES-4K"; + case HugeMode::HostEmulated: return "HOTE-EMULE"; + case HugeMode::Uninitialized: break; + } + return "NON-INITIALISE"; +} + +bool page_acquire(usize size, PageBlock& out) { + out = PageBlock{}; + if (size == 0 || (size % kHugePageSize) != 0) { + panic_v("page_acquire : taille non multiple de 2 Mo", "taille", + static_cast(size)); + } + + // --- Chemin 1 : huge pages reservees --------------------------------- + // MAP_HUGE_2MB est explicite : sans lui, MAP_HUGETLB prend la taille par + // defaut du systeme, qui peut etre 512 Mo sur certaines configurations et + // ferait echouer l appel pour une raison difficile a diagnostiquer. + // + // Echoue typiquement avec ENOMEM (pool hugetlbfs vide, cas le plus + // probable sur un noyau Android stock : nr_hugepages vaut 0 par defaut), + // EPERM, ou EINVAL si le noyau est compile sans CONFIG_HUGETLBFS. + { + const sys::Result r = map_anon(size, sys::MAP_HUGETLB | sys::MAP_HUGE_2MB); + if (r.is_ok()) { + out.base = static_cast(r.ptr()); + out.size = size; + out.mode = HugeMode::Hugetlb2MB; + g_active = out.mode; + return true; + } + } + + // --- Chemin 2 : pages classiques + conseil THP ------------------------ + { + const sys::Result r = map_anon(size, 0); + if (r.is_ok()) { + out.base = static_cast(r.ptr()); + out.size = size; + + const sys::Result a = sys::madvise(out.base, size, sys::MADV_HUGEPAGE); + if (a.is_ok()) { + out.mode = HugeMode::TransparentHuge; + } else { + // madvise echoue avec EINVAL si le noyau est compile sans + // CONFIG_TRANSPARENT_HUGEPAGE, ou si THP est en mode "never". + // Le mapping reste parfaitement utilisable : on tombe au + // chemin 3 sans refaire de mmap. + out.mode = HugeMode::PlainPages; + } + g_active = out.mode; + return true; + } + } + + // --- Les trois chemins ont echoue ------------------------------------- + // On ne panique pas ici : l appelant peut vouloir reessayer avec une + // taille plus petite, ou afficher un message plus precis. + return false; +} + +void page_release(PageBlock& block) { + if (block.base == nullptr) return; + (void)sys::munmap(block.base, block.size); + block = PageBlock{}; +} + +HugeMode active_mode() { return g_active; } + +void log_active_mode() { + err_write("proj3: memoire : mode retenu = "); + err_write(huge_mode_name(g_active)); + err_write("\n"); + if (mode_is_deterministic(g_active)) { + err_write("proj3: memoire : pages garanties, mesures de latence valides.\n"); + } else { + err_write("proj3: memoire : ATTENTION, pages NON garanties.\n"); + err_write("proj3: memoire : toute mesure de latence faite dans ce mode\n"); + err_write("proj3: memoire : porte une barre d erreur inconnue.\n"); + } +} + +} // namespace proj3::mem diff --git a/src/proj3/mem/system.cpp b/src/proj3/mem/system.cpp new file mode 100644 index 0000000..4e427ba --- /dev/null +++ b/src/proj3/mem/system.cpp @@ -0,0 +1,68 @@ +#include "proj3/mem/system.hpp" + +#include "proj3/mem/layout.hpp" +#include "proj3/sys/panic.hpp" + +namespace proj3::mem { + +bool system_init(System& out) { + if (!page_acquire(kArenaTotal, out.block)) return false; + + u8* p = out.block.base; + auto carve = [&p](Arena& a, const char* name, usize bytes) { + a.init(name, p, bytes); + p += bytes; + }; + + // L ordre n est pas indifferent : le scanout d abord, parce que c est la + // region la plus grosse et celle qu on voudra un jour passer telle quelle + // a un import DRM ; elle est donc a l offset 0 du bloc, donc alignee sur + // 2 Mo par construction. + carve(out.scanout, "scanout", kScanoutBytes); + carve(out.geometry, "geometrie", kGeometryBytes); + carve(out.atlas, "atlas", kAtlasBytes); + carve(out.input, "entree", kInputBytes); + carve(out.scratch, "scratch", kFrameScratchBytes); + + const usize consumed = static_cast(p - out.block.base); + if (consumed != kArenaTotalRaw) { + panic_v("decoupage des arenes incoherent avec layout.hpp", "consomme", + static_cast(consumed)); + } + + out.initialized = true; + return true; +} + +void system_begin_frame(System& s) { s.scratch.reset(); } + +namespace { + +void report_one(const Arena& a) { + err_write("proj3: arene "); + err_write(a.name()); + err_write(" : capacite="); + err_write_i64(static_cast(a.capacity())); + err_write(" pic="); + err_write_i64(static_cast(a.peak())); + err_write(" base="); + err_write_hex(reinterpret_cast(a.base())); + err_write("\n"); +} + +} // namespace + +void system_report(const System& s) { + err_write("proj3: budget memoire total = "); + err_write_i64(static_cast(kArenaTotal)); + err_write(" octets (reserve non decoupee = "); + err_write_i64(static_cast(kReserveBytes)); + err_write(")\n"); + report_one(s.scanout); + report_one(s.geometry); + report_one(s.atlas); + report_one(s.input); + report_one(s.scratch); +} + +} // namespace proj3::mem diff --git a/src/proj3/mem/system.hpp b/src/proj3/mem/system.hpp new file mode 100644 index 0000000..ba78721 --- /dev/null +++ b/src/proj3/mem/system.hpp @@ -0,0 +1,39 @@ +// mem/system.hpp — les arenes du projet, decoupees en une fois a l init. +// +// Un seul bloc est demande au noyau (kArenaTotal), puis decoupe. Raison : le +// repli huge pages ne vaut que sur une region contigue. Cinq mmap separes +// auraient cinq modes potentiellement differents, ce qui rendrait la question +// "quel mode est actif ?" sans reponse unique. +#pragma once + +#include "proj3/mem/arena.hpp" +#include "proj3/mem/page_source.hpp" + +namespace proj3::mem { + +struct System { + Arena scanout; // deux tampons d image + Arena geometry; // aretes du rasterizer + Arena atlas; // atlas de glyphes 8 bits + Arena input; // anneau d evenements d entree + Arena scratch; // remis a zero a chaque image + + PageBlock block; + + bool initialized = false; +}; + +// Acquiert le bloc et initialise les cinq arenes. +// Rend false si l acquisition des pages a echoue (les trois chemins). +// Ne panique pas : l appelant decide quoi dire. +bool system_init(System& out); + +// Remet a zero l arene de scratch. A appeler au debut de chaque image. +// C est la SEULE liberation memoire du projet. +void system_begin_frame(System& s); + +// Vidage lisible de l occupation de chaque arene. Sert a verifier que les +// tailles de mem/layout.hpp correspondent a la realite. +void system_report(const System& s); + +} // namespace proj3::mem diff --git a/src/proj3/render/compose.cpp b/src/proj3/render/compose.cpp new file mode 100644 index 0000000..6c54170 --- /dev/null +++ b/src/proj3/render/compose.cpp @@ -0,0 +1,54 @@ +#include "proj3/render/compose.hpp" + +#include "proj3/base/math.hpp" +#include "proj3/sys/panic.hpp" + +namespace proj3::render { + +Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h) { + Framebuffer fb; + fb.width = w; + fb.height = h; + fb.pixels = a.alloc_array(static_cast(w) * static_cast(h)); + return fb; +} + +void framebuffer_clear(Framebuffer& fb, u32 xrgb) { + const usize n = static_cast(fb.width) * static_cast(fb.height); + for (usize i = 0; i < n; ++i) fb.pixels[i] = xrgb; +} + +void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb) { + if (fb.empty() || cov.empty()) return; + + // L hypothese d alignement est verifiee, pas supposee : un tampon de + // destination desaligne rendrait tout futur noyau NEON incorrect, et le + // symptome apparaitrait tres loin d ici. + if ((reinterpret_cast(fb.pixels) & 3u) != 0) { + panic("compose_coverage : framebuffer non aligne sur 4 octets"); + } + + // Decoupage : on calcule d abord l intersection, puis on boucle sans + // aucun test par pixel. Un test de bord dans la boucle interne serait un + // branchement imprevisible par pixel, donc de la variance. + i32 sx0 = 0, sy0 = 0; + i32 sx1 = cov.width, sy1 = cov.height; + + if (dst_x < 0) sx0 = -dst_x; + if (dst_y < 0) sy0 = -dst_y; + if (dst_x + sx1 > fb.width) sx1 = fb.width - dst_x; + if (dst_y + sy1 > fb.height) sy1 = fb.height - dst_y; + if (sx0 >= sx1 || sy0 >= sy1) return; + + for (i32 y = sy0; y < sy1; ++y) { + const u8* src = cov.pixels + static_cast(y) * static_cast(cov.width); + u32* dst = fb.row(dst_y + y) + (dst_x + sx0); + for (i32 x = sx0; x < sx1; ++x) { + // Couverture binaire : 0 ou 255. On teste la valeur plutot que de + // melanger, parce qu il n y a rien a melanger (cf. compose.hpp). + if (src[x] != 0) dst[x - sx0] = xrgb; + } + } +} + +} // namespace proj3::render diff --git a/src/proj3/render/compose.hpp b/src/proj3/render/compose.hpp new file mode 100644 index 0000000..5f7353a --- /dev/null +++ b/src/proj3/render/compose.hpp @@ -0,0 +1,60 @@ +// render/compose.hpp — composition d une couverture 8 bits vers le framebuffer. +// +// POURQUOI CE FICHIER EXISTE SEPAREMENT DU RASTERIZER. +// Dans Gastinel Write, la rasterization et l ecriture dans le DIB Win32 +// etaient voisines, et le format BGRA du DIB s etait infiltre dans le +// raisonnement. Ici la frontiere est explicite : +// - le rasterizer produit de la COUVERTURE, une valeur par pixel, sans +// aucune notion de couleur ni de format ; +// - ce fichier, et lui seul, connait le format de destination. +// C est cette separation qui rendra possible d ecrire un noyau NEON de +// composition sans jamais toucher au rasterizer, et de valider les deux +// separement dans le harnais d oracle. +// +// FORMAT DE DESTINATION : XRGB8888 tel que l attend un plan DRM +// (DRM_FORMAT_XRGB8888). En memoire, sur une machine little-endian, un pixel +// occupe quatre octets dans l ordre B, G, R, X. Manipule comme un u32, cela +// donne 0xXXRRGGBB. +// +// HYPOTHESES, differentes de celles du code Windows d origine : +// - little-endian. Verifie par static_assert dans base/types.hpp. AArch64 +// tourne en little-endian sous Linux ; le mode big-endian existe mais +// n est pas utilise par Android ni par aucun noyau grand public. +// - Le tampon de destination est aligne sur 4 octets au minimum. Il vient +// d une arene dont la base est alignee sur 2 Mo, donc c est acquis ; la +// verification est faite a l entree pour que l hypothese ne devienne pas +// tacite. +// - Aucun alpha : le canal X est ecrit a 0xFF et jamais lu. Le rasterizer +// ne produisant qu une couverture binaire (dette heritee, cf. +// rasterizer.hpp), il n y a rien a melanger : un pixel est ecrit ou il ne +// l est pas. +#pragma once + +#include "proj3/mem/arena.hpp" +#include "proj3/render/coverage.hpp" + +namespace proj3::render { + +struct Framebuffer { + u32* pixels = nullptr; + i32 width = 0; + i32 height = 0; + + u32* row(i32 y) { return pixels + static_cast(y) * static_cast(width); } + const u32* row(i32 y) const { + return pixels + static_cast(y) * static_cast(width); + } + bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; } +}; + +Framebuffer framebuffer_alloc(mem::Arena& a, i32 w, i32 h); + +void framebuffer_clear(Framebuffer& fb, u32 xrgb); + +// Compose `cov` a la position (dst_x, dst_y) avec la couleur `xrgb`. +// La couverture etant binaire, un pixel de couverture non nulle ecrit la +// couleur telle quelle ; un pixel a zero ne touche pas la destination. +// Le decoupage aux bords du framebuffer est fait ici. +void compose_coverage(Framebuffer& fb, i32 dst_x, i32 dst_y, const Coverage8& cov, u32 xrgb); + +} // namespace proj3::render diff --git a/src/proj3/render/coverage.hpp b/src/proj3/render/coverage.hpp new file mode 100644 index 0000000..445947d --- /dev/null +++ b/src/proj3/render/coverage.hpp @@ -0,0 +1,54 @@ +// render/coverage.hpp — image de couverture 8 bits. +// +// Porte depuis Gastinel Write (src/render/bitmap.h, struct Coverage8), avec un +// changement de fond : les pixels ne sont plus dans un std::vector qui pousse, +// mais dans une arene fournie par l appelant. Il n y a donc plus de +// resize() ni de grow_height() : une couverture est dimensionnee une fois, a +// la creation. +// +// SEPARATION CENTRALE DU PORTAGE : ce type ne connait AUCUN format de pixel. +// C est de la couverture pure, une valeur par pixel, 0 = vide, 255 = plein. +// La conversion vers le format du framebuffer est un autre fichier +// (render/compose.hpp). C est cette separation qui rendra possible d ecrire +// des noyaux NEON de composition sans toucher au rasterizer. +#pragma once + +#include "proj3/base/mem.hpp" +#include "proj3/base/types.hpp" +#include "proj3/mem/arena.hpp" + +namespace proj3::render { + +struct Coverage8 { + u8* pixels = nullptr; + i32 width = 0; + i32 height = 0; + + // Pas de stride distinct de la largeur : les lignes sont contigues. + // Un stride separe serait utile pour ecrire dans une sous-fenetre ; aucun + // usage du projet n en a besoin, et l ajouter maintenant compliquerait les + // futurs noyaux NEON pour rien. + usize size_bytes() const { + return static_cast(width) * static_cast(height); + } + + u8 at(i32 x, i32 y) const { + return pixels[static_cast(y) * static_cast(width) + static_cast(x)]; + } + void set(i32 x, i32 y, u8 v) { + pixels[static_cast(y) * static_cast(width) + static_cast(x)] = v; + } + bool empty() const { return width <= 0 || height <= 0 || pixels == nullptr; } +}; + +// Alloue une couverture w*h dans `a`, remise a zero. +inline Coverage8 coverage_alloc(mem::Arena& a, i32 w, i32 h) { + Coverage8 c; + c.width = w; + c.height = h; + c.pixels = a.alloc_array(static_cast(w) * static_cast(h)); + mem_fill(c.pixels, 0, c.size_bytes()); + return c; +} + +} // namespace proj3::render diff --git a/src/proj3/render/rasterizer.cpp b/src/proj3/render/rasterizer.cpp new file mode 100644 index 0000000..044c11a --- /dev/null +++ b/src/proj3/render/rasterizer.cpp @@ -0,0 +1,262 @@ +#include "proj3/render/rasterizer.hpp" + +#include "proj3/base/math.hpp" +#include "proj3/base/sort.hpp" + +namespace proj3::render { +namespace { + +struct Vec2 { + f32 x = 0.0f; + f32 y = 0.0f; +}; + +// Une arete non horizontale, prete pour le balayage. +// `winding` vaut +1 si l arete descend dans le repere bitmap, -1 sinon : c est +// ce signe qui alimente la regle nonzero. +struct Edge { + f32 x0, y0, x1, y1; + i32 winding; +}; + +struct Crossing { + f32 x; + i32 winding; +}; + +// Accumulateur d aretes a capacite fixe. Remplace le std::vector de +// l original. Le debordement est signale, jamais absorbe. +struct EdgeList { + Edge* data = nullptr; + u32 count = 0; + u32 cap = 0; + bool overflow = false; + + void push(const Edge& e) { + if (count >= cap) { + overflow = true; + return; + } + data[count++] = e; + } +}; + +// Nombre de segments utilises pour approcher une courbe quadratique. +// Calcule a partir de la longueur du polygone de controle : une courbe de 2 px +// n a pas besoin du meme decoupage qu une courbe de 200 px. La borne haute +// evite qu une taille absurde fasse exploser la liste d aretes. +// +// C est le SEUL endroit du portage ou la valeur numerique peut, en theorie, +// differer de celle de Write : hypot_f64 est un calcul naif la ou l original +// appelait std::hypot. Cf. base/math.hpp. +i32 subdivision_count(const Vec2& p0, const Vec2& p1, const Vec2& p2) { + const f64 d = hypot_f64(static_cast(p1.x) - p0.x, static_cast(p1.y) - p0.y) + + hypot_f64(static_cast(p2.x) - p1.x, static_cast(p2.y) - p1.y); + const i32 n = static_cast(ceil_f32(static_cast(d) / 1.5f)); + return clamp_to(n, 2, 64); +} + +void emit_edge(EdgeList& edges, const Vec2& a, const Vec2& b) { + if (a.y == b.y) return; // arete horizontale : aucune intersection utile + if (a.y < b.y) { + edges.push(Edge{a.x, a.y, b.x, b.y, +1}); + } else { + edges.push(Edge{b.x, b.y, a.x, a.y, -1}); + } +} + +void emit_quadratic(EdgeList& edges, const Vec2& p0, const Vec2& ctrl, const Vec2& p1) { + const i32 n = subdivision_count(p0, ctrl, p1); + Vec2 prev = p0; + for (i32 i = 1; i <= n; ++i) { + const f32 t = static_cast(i) / static_cast(n); + const f32 u = 1.0f - t; + Vec2 cur; + cur.x = u * u * p0.x + 2.0f * u * t * ctrl.x + t * t * p1.x; + cur.y = u * u * p0.y + 2.0f * u * t * ctrl.y + t * t * p1.y; + emit_edge(edges, prev, cur); + prev = cur; + } +} + +Vec2 midpoint(const Vec2& a, const Vec2& b) { + return Vec2{(a.x + b.x) * 0.5f, (a.y + b.y) * 0.5f}; +} + +// Convertit un contour TrueType en aretes, en resolvant les points de controle +// implicites : deux points off-curve consecutifs sous-entendent un point +// on-curve situe exactement a leur milieu. C est une compression du format, pas +// une approximation — le milieu est la vraie position du point. +void flatten_contour(const font::GlyphPoint* pts, u32 n, f32 scale, f32 origin_x, f32 origin_y, + EdgeList& edges) { + if (n < 2) return; + + // Repere bitmap : X vers la droite, Y vers le bas (d ou le signe negatif). + auto to_device = [&](const font::GlyphPoint& p) { + return Vec2{p.x * scale - origin_x, origin_y - p.y * scale}; + }; + + // Le contour peut tres bien commencer par un point de controle. + u32 start_index = 0; + Vec2 start{}; + bool found_on_curve = false; + for (u32 i = 0; i < n; ++i) { + if (pts[i].on_curve) { + start_index = i; + start = to_device(pts[i]); + found_on_curve = true; + break; + } + } + if (!found_on_curve) { + // Contour entierement off-curve : le point de depart est le milieu + // entre le dernier et le premier point de controle. + start = midpoint(to_device(pts[n - 1]), to_device(pts[0])); + start_index = 0; + } + + Vec2 cursor = start; + bool have_ctrl = false; + Vec2 ctrl{}; + + const u32 first = found_on_curve ? start_index + 1 : start_index; + for (u32 k = 0; k < n; ++k) { + const u32 i = (first + k) % n; + if (found_on_curve && i == start_index) break; + + const Vec2 p = to_device(pts[i]); + if (pts[i].on_curve) { + if (have_ctrl) { + emit_quadratic(edges, cursor, ctrl, p); + have_ctrl = false; + } else { + emit_edge(edges, cursor, p); + } + cursor = p; + } else { + if (have_ctrl) { + const Vec2 implied = midpoint(ctrl, p); + emit_quadratic(edges, cursor, ctrl, implied); + cursor = implied; + } + ctrl = p; + have_ctrl = true; + } + } + + // Fermeture du contour, en consommant un eventuel controle en attente. + if (have_ctrl) { + emit_quadratic(edges, cursor, ctrl, start); + } else { + emit_edge(edges, cursor, start); + } +} + +} // namespace + +bool rasterize_glyph(const font::Glyph& glyph, u16 units_per_em, f32 pixel_size, + mem::Arena& out_arena, mem::Arena& scratch, RasterizedGlyph& out) { + out = RasterizedGlyph{}; + if (units_per_em == 0 || pixel_size <= 0.0f) return false; + + const f32 scale = pixel_size / static_cast(units_per_em); + out.advance = lround_f32(glyph.advance_width * scale); + + if (glyph.empty()) return false; + + // Bornes reelles calculees depuis les points plutot que depuis la bbox + // declaree : les points de controle peuvent depasser la bbox, et une bbox + // fausse (ca existe) produirait des contours coupes. + f32 min_x = 1e30f, min_y = 1e30f, max_x = -1e30f, max_y = -1e30f; + for (u32 i = 0; i < glyph.point_count; ++i) { + const font::GlyphPoint& p = glyph.points[i]; + min_x = min_of(min_x, p.x); + min_y = min_of(min_y, p.y); + max_x = max_of(max_x, p.x); + max_y = max_of(max_y, p.y); + } + if (min_x > max_x) return false; + + // Un pixel de marge de chaque cote absorbe les arrondis. + const i32 px_min_x = static_cast(floor_f32(min_x * scale)) - 1; + const i32 px_max_x = static_cast(ceil_f32(max_x * scale)) + 1; + const i32 px_min_y = static_cast(floor_f32(min_y * scale)) - 1; + const i32 px_max_y = static_cast(ceil_f32(max_y * scale)) + 1; + + const i32 w = px_max_x - px_min_x; + const i32 h = px_max_y - px_min_y; + if (w <= 0 || h <= 0 || w > 8192 || h > 8192) return false; + + const usize scratch_mark = scratch.mark(); + + EdgeList edges; + edges.data = scratch.alloc_array(kMaxEdges); + edges.cap = kMaxEdges; + + for (u32 c = 0; c < glyph.contour_count; ++c) { + const u32 b = glyph.contour_begin(c); + flatten_contour(glyph.points + b, glyph.contour_size(c), scale, + static_cast(px_min_x), static_cast(px_max_y), edges); + } + if (edges.overflow) { + // Refus explicite. L original aurait fait croitre son vector, donc + // alloue en plein rendu : c est exactement ce qu on interdit. + scratch.rewind_to(scratch_mark); + return false; + } + if (edges.count == 0) { + scratch.rewind_to(scratch_mark); + return false; + } + + // La couverture est allouee APRES les aretes et dans une AUTRE arene : + // elle survit au rembobinage du scratch. + out.bearing_x = px_min_x; + out.bearing_y = px_max_y; // haut du bitmap, au-dessus de la ligne de base + out.coverage = coverage_alloc(out_arena, w, h); + + // --- Balayage --- + // Une passe par ligne, echantillonnee au centre du pixel (y + 0.5). Les + // intersections sont collectees puis triees par x ; le compteur de winding + // s incremente en traversant chaque arete et la ligne est remplie partout + // ou il est non nul. + Crossing* crossings = scratch.alloc_array(kMaxEdges); + + for (i32 y = 0; y < h; ++y) { + const f32 sample_y = static_cast(y) + 0.5f; + u32 nc = 0; + + for (u32 e = 0; e < edges.count; ++e) { + const Edge& ed = edges.data[e]; + // Intervalle semi-ouvert [y0, y1) : indispensable pour qu un + // sommet partage par deux aretes ne compte qu une fois. + if (sample_y < ed.y0 || sample_y >= ed.y1) continue; + const f32 t = (sample_y - ed.y0) / (ed.y1 - ed.y0); + crossings[nc++] = Crossing{ed.x0 + t * (ed.x1 - ed.x0), ed.winding}; + } + if (nc < 2) continue; + + heap_sort(crossings, nc, [](const Crossing& a, const Crossing& b) { return a.x < b.x; }); + + i32 winding = 0; + for (u32 i = 0; i + 1 < nc; ++i) { + winding += crossings[i].winding; + if (winding == 0) continue; + + const f32 span_start = crossings[i].x; + const f32 span_end = crossings[i + 1].x; + + // On remplit les pixels dont le centre tombe dans le span. + i32 x0 = static_cast(ceil_f32(span_start - 0.5f)); + i32 x1 = static_cast(ceil_f32(span_end - 0.5f)); + x0 = max_of(x0, 0); + x1 = min_of(x1, w); + for (i32 x = x0; x < x1; ++x) out.coverage.set(x, y, 255); + } + } + + scratch.rewind_to(scratch_mark); + return true; +} + +} // namespace proj3::render diff --git a/src/proj3/render/rasterizer.hpp b/src/proj3/render/rasterizer.hpp new file mode 100644 index 0000000..9a6d641 --- /dev/null +++ b/src/proj3/render/rasterizer.hpp @@ -0,0 +1,73 @@ +// render/rasterizer.hpp — rasterization scanline, portee depuis Gastinel Write. +// +// REGLE DE REMPLISSAGE : NONZERO WINDING. Inchangee, et ce n est pas une +// preference : c est la regle qu impose la specification TrueType. Les +// contours d un glyphe sont orientes (exterieur horaire, interieur +// anti-horaire) precisement pour que le nonzero creuse les contreformes. En +// even-odd, deux contours exterieurs qui se chevauchent — frequent apres +// decomposition d un composite, un accent qui mord sur la lettre — laisseraient +// un trou a l intersection. +// +// DETTE TECHNIQUE HERITEE, CONSERVEE TELLE QUELLE : +// - aucun antialiasing : la couverture vaut 0 ou 255, jamais autre chose ; +// - aucun hinting ; +// - aucun crenage (c est le parser qui l ignore, pas le rasterizer). +// Ces trois choix sont volontaires cote Write et ne sont pas revus ici. +// L avis du portage figure dans le rapport, pas dans le code. +// +// CE QUI CHANGE PAR RAPPORT A L ORIGINAL : +// 1. Plus aucune allocation. Les aretes et les intersections viennent d une +// arene de travail fournie par l appelant ; la couverture est ecrite dans +// une arene de sortie fournie par l appelant. Le rasterizer n alloue +// jamais, et le garde-fou du chantier 3 le prouve. +// 2. std::sort devient un heapsort maison a cout pire cas borne +// (base/sort.hpp). Le tri porte sur des abscisses ; deux intersections de +// meme abscisse delimitent un intervalle de largeur nulle, donc +// l instabilite du heapsort est sans effet sur la sortie. +// 3. std::hypot devient un calcul naif en double (base/math.hpp). Seule +// divergence numerique connue du portage ; elle est bornee a moins d un +// ULP de float et verifiee par le test golden. +// 4. Le nombre d aretes est plafonne. L original laissait le vector croitre ; +// ici un depassement est un echec explicite, pas une allocation. +#pragma once + +#include "proj3/font/ttf.hpp" +#include "proj3/mem/arena.hpp" +#include "proj3/render/coverage.hpp" + +namespace proj3::render { + +// Plafond du nombre d aretes par glyphe. Justification dans mem/layout.hpp +// (majorant raisonne : 600 points * 64 subdivisions = 38400). +inline constexpr u32 kMaxEdges = 65536; + +struct RasterizedGlyph { + Coverage8 coverage; + + // Coin haut-gauche du bitmap par rapport a l origine du glyphe (le point + // de base sur la ligne de base), en pixels. bearing_y est positif vers le + // haut, convention typographique. + i32 bearing_x = 0; + i32 bearing_y = 0; + + // Avance horizontale en pixels, arrondie a l entier le plus proche. + i32 advance = 0; +}; + +// Rasterise un glyphe a `pixel_size` pixels par em. +// +// Le glyphe arrive en unites de police ; la conversion utilise units_per_em. +// Le repere TrueType a son axe Y vers le haut, le bitmap vers le bas : la +// conversion est faite ici, une seule fois. +// +// `out_arena` : recoit les pixels de couverture (duree de vie longue). +// `scratch` : aretes et intersections (rembobinee avant de rendre la main). +// +// Rend false si le glyphe est vide, si la taille est invalide, ou si le +// plafond d aretes est atteint ; dans ce cas seules les metriques de `out` +// sont renseignees. C est le comportement de l original, plus le cas du +// plafond qui n existait pas. +bool rasterize_glyph(const font::Glyph& glyph, u16 units_per_em, f32 pixel_size, + mem::Arena& out_arena, mem::Arena& scratch, RasterizedGlyph& out); + +} // namespace proj3::render diff --git a/src/proj3/sys/panic.cpp b/src/proj3/sys/panic.cpp new file mode 100644 index 0000000..6e8b403 --- /dev/null +++ b/src/proj3/sys/panic.cpp @@ -0,0 +1,57 @@ +// sys/panic.cpp — implementation embarquee (AArch64, sans libc). +#include "proj3/sys/panic.hpp" + +#include "proj3/base/fmt.hpp" +#include "proj3/sys/syscalls.hpp" +#include "proj3/sys/uapi.hpp" + +namespace proj3 { + +void err_write_bytes(const void* p, usize n) { + const u8* cur = static_cast(p); + usize left = n; + // Une ecriture peut etre partielle. La boucle est bornee : chaque tour + // consomme au moins un octet, sinon on abandonne. Pas de boucle infinie + // possible, ce qui compte sur un chemin de panique. + while (left > 0) { + const sys::Result r = sys::write(sys::FD_STDERR, cur, left); + if (r.is_err() || r.value() <= 0) return; + const usize done = static_cast(r.value()); + cur += done; + left -= done; + } +} + +void err_write(const char* s) { err_write_bytes(s, str_len(s)); } + +void err_write_i64(i64 v) { + char buf[kDecBufSize]; + const usize n = fmt_i64(buf, sizeof(buf), v); + err_write_bytes(buf, n); +} + +void err_write_hex(u64 v) { + char buf[kDecBufSize]; + const usize n = fmt_hex_u64(buf, sizeof(buf), v); + err_write_bytes(buf, n); +} + +[[noreturn]] void panic(const char* what) { + err_write("proj3: PANIQUE: "); + err_write(what); + err_write("\n"); + sys::exit_group(70); +} + +[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) { + err_write("proj3: PANIQUE: "); + err_write(what); + err_write(" ["); + err_write(detail); + err_write("="); + err_write_i64(value); + err_write("]\n"); + sys::exit_group(70); +} + +} // namespace proj3 diff --git a/src/proj3/sys/panic.hpp b/src/proj3/sys/panic.hpp new file mode 100644 index 0000000..70566b6 --- /dev/null +++ b/src/proj3/sys/panic.hpp @@ -0,0 +1,32 @@ +// sys/panic.hpp — arret bruyant. +// +// Le projet n a pas de gestion d erreur recuperable au-dela du point ou une +// decision de repli est prise sur place (cf. doc/convention-syscall.md 3.3). +// Tout le reste est un defaut de conception, et un defaut de conception doit +// s arreter immediatement, la ou il se produit, avec de quoi le localiser. +// +// Deux implementations, une par cible : +// sys/panic.cpp (embarquee) : write(2) direct + exit_group(70) +// sys/panic_host.cpp (hote) : fwrite(stderr) + _Exit(70) +// Le code portable ne voit que ces declarations. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3 { + +// Ecrit tel quel sur la sortie d erreur. Pas de tampon, pas de retour de +// statut : si l ecriture echoue, il n y a rien de sense a faire. +void err_write(const char* s); +void err_write_bytes(const void* p, usize n); +void err_write_i64(i64 v); +void err_write_hex(u64 v); + +// Code de sortie 70 : EX_SOFTWARE de sysexits.h. Choisi parce qu il est +// distinct de tout code d erreur applicatif et reconnaissable dans un script. +[[noreturn]] void panic(const char* what); + +// Variante avec un detail et une valeur (code errno, offset, taille...). +[[noreturn]] void panic_v(const char* what, const char* detail, i64 value); + +} // namespace proj3 diff --git a/src/proj3/sys/panic_host.cpp b/src/proj3/sys/panic_host.cpp new file mode 100644 index 0000000..d7a7e06 --- /dev/null +++ b/src/proj3/sys/panic_host.cpp @@ -0,0 +1,54 @@ +// sys/panic_host.cpp — implementation HOTE. +// +// Cette unite a le droit d utiliser la libc de l hote (cf. ADR-0001). Elle +// n est JAMAIS compilee pour la cible embarquee. +// +// _Exit et non exit : on ne veut ni vidage des flux ni appel des destructeurs +// statiques, pour que le comportement soit aussi brutal que sur la cible. +#include "proj3/sys/panic.hpp" + +#include +#include + +#include "proj3/base/fmt.hpp" + +namespace proj3 { + +void err_write_bytes(const void* p, usize n) { + std::fwrite(p, 1, n, stderr); + std::fflush(stderr); +} + +void err_write(const char* s) { err_write_bytes(s, str_len(s)); } + +void err_write_i64(i64 v) { + char buf[kDecBufSize]; + const usize n = fmt_i64(buf, sizeof(buf), v); + err_write_bytes(buf, n); +} + +void err_write_hex(u64 v) { + char buf[kDecBufSize]; + const usize n = fmt_hex_u64(buf, sizeof(buf), v); + err_write_bytes(buf, n); +} + +[[noreturn]] void panic(const char* what) { + err_write("proj3: PANIQUE: "); + err_write(what); + err_write("\n"); + std::_Exit(70); +} + +[[noreturn]] void panic_v(const char* what, const char* detail, i64 value) { + err_write("proj3: PANIQUE: "); + err_write(what); + err_write(" ["); + err_write(detail); + err_write("="); + err_write_i64(value); + err_write("]\n"); + std::_Exit(70); +} + +} // namespace proj3 diff --git a/src/proj3/sys/result.hpp b/src/proj3/sys/result.hpp new file mode 100644 index 0000000..f64d030 --- /dev/null +++ b/src/proj3/sys/result.hpp @@ -0,0 +1,36 @@ +// sys/result.hpp — valeur de retour d un appel systeme. +// +// Convention arretee au chantier 1 : doc/convention-syscall.md, option C. +// Le wrapper rend le x0 du noyau tel quel. Ce type est une enveloppe de cout +// nul : sizeof == 8, trivialement copiable, donc passee et rendue en registre +// exactement comme un i64 nu. +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3::sys { + +struct [[nodiscard]] Result { + i64 raw; + + // Plage d erreur EXACTE du noyau : [-4095, -1]. C est la definition de + // IS_ERR_VALUE (include/linux/err.h, MAX_ERRNO = 4095). + // + // Ce n est pas "raw < 0" : mmap peut legitimement rendre une adresse dont + // le bit 63 est a 1, et lseek une position au-dela de 2^63. Le test + // approximatif serait faux, pas seulement imprecis. + constexpr bool is_err() const { return raw < 0 && raw >= -4095; } + constexpr bool is_ok() const { return !is_err(); } + + // Code errno positif. Precondition : is_err(). + constexpr i32 err() const { return static_cast(-raw); } + + // Valeur utile. Precondition : is_ok(). + constexpr i64 value() const { return raw; } + constexpr i32 fd() const { return static_cast(raw); } + void* ptr() const { return reinterpret_cast(static_cast(raw)); } +}; + +static_assert(sizeof(Result) == 8, "Result doit tenir dans un registre"); + +} // namespace proj3::sys diff --git a/src/proj3/sys/syscall_nr.hpp b/src/proj3/sys/syscall_nr.hpp new file mode 100644 index 0000000..4a83d70 --- /dev/null +++ b/src/proj3/sys/syscall_nr.hpp @@ -0,0 +1,50 @@ +// sys/syscall_nr.hpp — numeros d appels systeme AArch64. +// +// SOURCE DE LA TABLE (unique et citee, comme demande) : +// Linux, include/uapi/asm-generic/unistd.h +// AArch64 n a PAS de table de syscalls propre : arch/arm64/include/asm/ +// unistd.h se contente d inclure la table generique asm-generic. Les +// numeros ci-dessous sont donc ceux de la table generique 64 bits, valables +// pour tout portage recent (arm64, riscv64, loongarch...). +// +// Ils sont STABLES : le noyau garantit qu un numero attribue ne change +// jamais. Verifier une valeur ne demande qu un grep dans unistd.h. +// +// CES NUMEROS DIFFERENT DE x86-64. Exemples de pieges : +// write vaut 64 ici, 1 sur x86-64 +// mmap vaut 222 ici, 9 sur x86-64 +// read vaut 63 ici, 0 sur x86-64 +// Aucun numero n a ete recopie de memoire depuis une table x86-64. +// +// ABSENCES NOTABLES de la table generique, qui ont des consequences ici : +// - PAS de __NR_open. Seul openat existe (56). open(path, flags, mode) +// se rend par openat(AT_FDCWD, path, flags, mode). +// - PAS de __NR_stat / __NR_lstat. Seuls fstat (80) et fstatat (79). +// - PAS de __NR_mmap2. mmap (222) prend un offset en OCTETS, pas en pages. +// +// La regle du chantier : ces constantes ne sont JAMAIS ecrites en dur dans le +// corps d une routine assembleur. Le fichier .S inclut celui-ci (il est ecrit +// pour etre lisible par le preprocesseur C ET par C++). +#pragma once + +#define PROJ3_NR_ioctl 29 +#define PROJ3_NR_openat 56 +#define PROJ3_NR_close 57 +#define PROJ3_NR_lseek 62 +#define PROJ3_NR_read 63 +#define PROJ3_NR_write 64 +#define PROJ3_NR_fstat 80 +#define PROJ3_NR_exit 93 +#define PROJ3_NR_exit_group 94 +#define PROJ3_NR_nanosleep 101 +#define PROJ3_NR_clock_gettime 113 +#define PROJ3_NR_getpid 172 +#define PROJ3_NR_munmap 215 +#define PROJ3_NR_mmap 222 +#define PROJ3_NR_madvise 233 + +// AT_FDCWD : descripteur special designant le repertoire courant pour les +// appels *at. Valeur -100, definie dans include/uapi/linux/fcntl.h. +// Elle est ici parce que le wrapper open l utilise ; ce n est pas un numero +// de syscall mais elle appartient au meme contrat. +#define PROJ3_AT_FDCWD (-100) diff --git a/src/proj3/sys/syscalls.hpp b/src/proj3/sys/syscalls.hpp new file mode 100644 index 0000000..b5a2b74 --- /dev/null +++ b/src/proj3/sys/syscalls.hpp @@ -0,0 +1,153 @@ +// sys/syscalls.hpp — declarations C++ des wrappers de asm/syscall.S. +// +// Toutes rendent proj3::sys::Result (cf. doc/convention-syscall.md). +// +// PAS DE VARIADIQUE — decision et justification : +// +// En C, open() et ioctl() sont declares variadiques : +// int open(const char*, int, ...); +// int ioctl(int, unsigned long, ...); +// C est un artefact historique de la libc, pas une propriete du noyau : le +// noyau recoit toujours un nombre fixe d arguments dans des registres fixes. +// +// Une signature variadique nous couterait trois choses, toutes contraires aux +// piliers : +// 1. L AAPCS64 impose un traitement DIFFERENT des arguments variadiques +// (zone de sauvegarde des registres, va_list). Un wrapper assembleur nu +// ne peut pas les recuperer de facon portable. +// 2. Elle supprime toute verification de type a l appel : passer un int la +// ou le pilote attend un pointeur compile sans un mot. +// 3. Elle empeche le compilateur de savoir combien de registres sont +// reellement vivants a l appel. +// +// On declare donc des SURCHARGES EXPLICITES, une par forme reellement +// utilisee. Ajouter une forme = ajouter une surcharge, pas assouplir le type. +#pragma once + +#include "proj3/base/types.hpp" +#include "proj3/sys/result.hpp" + +namespace proj3::sys { + +// struct timespec du noyau (asm-generic). 16 octets sur LP64. +struct TimeSpec { + i64 sec; + i64 nsec; +}; +static_assert(sizeof(TimeSpec) == 16); + +// struct stat du noyau AArch64. +// Source : include/uapi/asm-generic/stat.h (arm64 utilise la version +// generique 64 bits). Attention : ce N EST PAS la struct stat de la glibc, +// qui a une disposition differente. Ne jamais passer un stat de libc ici. +struct Stat { + u64 dev; + u64 ino; + u32 mode; + u32 nlink; + u32 uid; + u32 gid; + u64 rdev; + u64 pad1; + i64 size; + i32 blksize; + i32 pad2; + i64 blocks; + i64 atime_sec, atime_nsec; + i64 mtime_sec, mtime_nsec; + i64 ctime_sec, ctime_nsec; + u32 unused4, unused5; +}; +static_assert(sizeof(Stat) == 128, "disposition de struct stat AArch64"); + +} // namespace proj3::sys + +// --- Symboles bruts exportes par asm/syscall.S ----------------------------- +// Declares avec les types exacts attendus par l assembleur. Ils ne sont pas +// destines a un usage direct : la couche C++ ci-dessous les enveloppe. +extern "C" { +proj3::i64 proj3_sys_open(const char* path, proj3::i32 flags, proj3::u32 mode); +proj3::i64 proj3_sys_close(proj3::i32 fd); +proj3::i64 proj3_sys_read(proj3::i32 fd, void* buf, proj3::usize count); +proj3::i64 proj3_sys_write(proj3::i32 fd, const void* buf, proj3::usize count); +proj3::i64 proj3_sys_ioctl(proj3::i32 fd, proj3::u64 request, void* argp); +proj3::i64 proj3_sys_mmap(void* addr, proj3::usize length, proj3::i32 prot, + proj3::i32 flags, proj3::i32 fd, proj3::i64 offset); +proj3::i64 proj3_sys_munmap(void* addr, proj3::usize length); +proj3::i64 proj3_sys_madvise(void* addr, proj3::usize length, proj3::i32 advice); +proj3::i64 proj3_sys_clock_gettime(proj3::i32 clk, proj3::sys::TimeSpec* out); +proj3::i64 proj3_sys_nanosleep(const proj3::sys::TimeSpec* req, + proj3::sys::TimeSpec* rem); +proj3::i64 proj3_sys_getpid(void); +proj3::i64 proj3_sys_fstat(proj3::i32 fd, proj3::sys::Stat* out); +proj3::i64 proj3_sys_lseek(proj3::i32 fd, proj3::i64 offset, proj3::i32 whence); +[[noreturn]] void proj3_sys_exit(proj3::i32 code); +[[noreturn]] void proj3_sys_exit_group(proj3::i32 code); +} + +namespace proj3::sys { + +// --- open : surcharges explicites au lieu du variadique ------------------- + +// Ouverture sans creation. `mode` n est pas transmis parce qu il n a aucun +// sens sans O_CREAT ; le noyau l ignorerait, mais le laisser dans la +// signature laisserait croire qu il sert. +inline Result open(const char* path, i32 flags) { + return Result{proj3_sys_open(path, flags, 0)}; +} + +// Ouverture avec creation. Forme distincte, exigeant le mode : impossible +// d appeler O_CREAT en oubliant les permissions, ce qui donnerait un fichier +// aux droits aleatoires (le bug classique du open variadique). +inline Result open_create(const char* path, i32 flags, u32 mode) { + return Result{proj3_sys_open(path, flags, mode)}; +} + +inline Result close(i32 fd) { return Result{proj3_sys_close(fd)}; } +inline Result read(i32 fd, void* buf, usize n) { return Result{proj3_sys_read(fd, buf, n)}; } +inline Result write(i32 fd, const void* buf, usize n) { + return Result{proj3_sys_write(fd, buf, n)}; +} + +// --- ioctl : surcharges explicites ---------------------------------------- +// Les trois seules formes qui existent reellement au niveau du noyau : sans +// argument, avec un argument entier passe par valeur, avec un pointeur. +// Le troisieme argument est TOUJOURS place dans x2 ; ces surcharges ne font +// que rendre le type explicite a l appel. +inline Result ioctl(i32 fd, u64 request) { + return Result{proj3_sys_ioctl(fd, request, nullptr)}; +} +inline Result ioctl(i32 fd, u64 request, void* argp) { + return Result{proj3_sys_ioctl(fd, request, argp)}; +} +inline Result ioctl_val(i32 fd, u64 request, u64 value) { + return Result{proj3_sys_ioctl(fd, request, reinterpret_cast(value))}; +} + +inline Result mmap(void* addr, usize length, i32 prot, i32 flags, i32 fd, i64 offset) { + return Result{proj3_sys_mmap(addr, length, prot, flags, fd, offset)}; +} +inline Result munmap(void* addr, usize length) { + return Result{proj3_sys_munmap(addr, length)}; +} +inline Result madvise(void* addr, usize length, i32 advice) { + return Result{proj3_sys_madvise(addr, length, advice)}; +} + +inline Result clock_gettime(i32 clk, TimeSpec* out) { + return Result{proj3_sys_clock_gettime(clk, out)}; +} +inline Result nanosleep(const TimeSpec* req, TimeSpec* rem) { + return Result{proj3_sys_nanosleep(req, rem)}; +} + +inline Result getpid() { return Result{proj3_sys_getpid()}; } +inline Result fstat(i32 fd, Stat* out) { return Result{proj3_sys_fstat(fd, out)}; } +inline Result lseek(i32 fd, i64 offset, i32 whence) { + return Result{proj3_sys_lseek(fd, offset, whence)}; +} + +[[noreturn]] inline void exit(i32 code) { proj3_sys_exit(code); } +[[noreturn]] inline void exit_group(i32 code) { proj3_sys_exit_group(code); } + +} // namespace proj3::sys diff --git a/src/proj3/sys/uapi.hpp b/src/proj3/sys/uapi.hpp new file mode 100644 index 0000000..3b4cd8e --- /dev/null +++ b/src/proj3/sys/uapi.hpp @@ -0,0 +1,75 @@ +// sys/uapi.hpp — constantes de l interface noyau utilisees par le projet. +// +// REGLE : on ne definit ici que ce qu on utilise reellement. Pas de recopie +// exhaustive d en-tetes systeme. Chaque bloc cite sa source dans le noyau. +// +// Toutes ces valeurs sont celles de la variante ASM-GENERIC, celle qu utilise +// arm64. Elles ne sont pas toutes identiques a x86-64 (O_CREAT et MAP_* le +// sont ; d autres, comme les numeros de syscall, ne le sont pas du tout). +#pragma once + +#include "proj3/base/types.hpp" + +namespace proj3::sys { + +// --- include/uapi/asm-generic/fcntl.h ------------------------------------- +inline constexpr i32 O_RDONLY = 0; +inline constexpr i32 O_WRONLY = 1; +inline constexpr i32 O_RDWR = 2; +inline constexpr i32 O_CREAT = 0100; // octal, comme dans l en-tete d origine +inline constexpr i32 O_TRUNC = 01000; +inline constexpr i32 O_CLOEXEC = 02000000; + +// --- include/uapi/asm-generic/mman-common.h ------------------------------- +inline constexpr i32 PROT_NONE = 0; +inline constexpr i32 PROT_READ = 1; +inline constexpr i32 PROT_WRITE = 2; + +inline constexpr i32 MAP_SHARED = 0x01; +inline constexpr i32 MAP_PRIVATE = 0x02; +inline constexpr i32 MAP_FIXED = 0x10; +inline constexpr i32 MAP_ANONYMOUS = 0x20; +// --- include/uapi/asm-generic/mman.h (extensions Linux) ------------------- +inline constexpr i32 MAP_POPULATE = 0x8000; +inline constexpr i32 MAP_HUGETLB = 0x40000; + +// Selection explicite de la taille de huge page. Sans ces bits, MAP_HUGETLB +// utilise la taille par defaut du systeme, qui n est pas garantie a 2 Mo. +// include/uapi/linux/mman.h : MAP_HUGE_SHIFT = 26. +inline constexpr i32 MAP_HUGE_SHIFT = 26; +inline constexpr i32 MAP_HUGE_2MB = 21 << MAP_HUGE_SHIFT; + +inline constexpr i32 MADV_WILLNEED = 3; +inline constexpr i32 MADV_HUGEPAGE = 14; + +// --- include/uapi/linux/time.h -------------------------------------------- +inline constexpr i32 CLOCK_REALTIME = 0; +inline constexpr i32 CLOCK_MONOTONIC = 1; +inline constexpr i32 CLOCK_MONOTONIC_RAW = 4; + +// --- include/uapi/linux/fs.h ---------------------------------------------- +inline constexpr i32 SEEK_SET = 0; +inline constexpr i32 SEEK_CUR = 1; +inline constexpr i32 SEEK_END = 2; + +// --- Descripteurs standards ----------------------------------------------- +// Ils ne sont pas "de la libc" : c est le noyau qui les etablit a l exec. +inline constexpr i32 FD_STDOUT = 1; +inline constexpr i32 FD_STDERR = 2; + +// --- include/uapi/asm-generic/errno-base.h et errno.h --------------------- +// Uniquement les codes que le projet teste explicitement. +inline constexpr i32 EPERM = 1; +inline constexpr i32 ENOENT = 2; +inline constexpr i32 EINTR = 4; +inline constexpr i32 EBADF = 9; +inline constexpr i32 ENOMEM = 12; +inline constexpr i32 EACCES = 13; +inline constexpr i32 EFAULT = 14; +inline constexpr i32 ENODEV = 19; +inline constexpr i32 EINVAL = 22; +inline constexpr i32 ENOTTY = 25; +inline constexpr i32 ESPIPE = 29; +inline constexpr i32 ENOSYS = 38; + +} // namespace proj3::sys diff --git a/test/data/Inter-Regular.ttf b/test/data/Inter-Regular.ttf new file mode 100644 index 0000000..b7aaca8 Binary files /dev/null and b/test/data/Inter-Regular.ttf differ diff --git a/test/data/OFL.txt b/test/data/OFL.txt new file mode 100644 index 0000000..9b2ca37 --- /dev/null +++ b/test/data/OFL.txt @@ -0,0 +1,92 @@ +Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION AND CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/test/data/golden_write.txt b/test/data/golden_write.txt new file mode 100644 index 0000000..3d6d57a --- /dev/null +++ b/test/data/golden_write.txt @@ -0,0 +1,122 @@ +# proj3 golden raster dump v1 (source : Gastinel Write) +# upem 2048 +32 12 1777 0 0 0 0 0 3 +32 16 1777 0 0 0 0 0 5 +32 24 1777 0 0 0 0 0 7 +32 32 1777 0 0 0 0 0 9 +33 12 1427 1 5 12 -1 10 3 00000000000000ff00000000ff00000000ff00000000ff00000000ff00000000ff0000000000000000000000000000ff000000000000000000000000 +33 16 1427 1 5 15 0 13 5 00000000000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000ff00000000000000000000000000ffff000000ffff000000000000000000000000 +33 24 1427 1 7 21 0 19 7 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff0000000000000000000000000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000 +33 32 1427 1 7 27 1 25 9 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000000000000000000000ffffff00000000ffffffff000000ffffffff000000ffffff00000000000000000000000000000000 +44 12 1501 1 5 7 -1 3 3 000000000000000000000000ff00000000ff00000000ff000000000000000000000000 +44 16 1501 1 5 7 0 3 5 00000000000000ff00000000ff000000ffff000000ff00000000ff0000000000000000 +44 24 1501 1 6 10 0 4 7 0000000000000000000000000000ffffff000000ffff00000000ffff00000000ffff00000000ffff00000000ff000000000000000000000000000000 +44 32 1501 1 7 12 1 5 9 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff00000000ffffff00000000ffffff00000000ffff0000000000ffff0000000000000000000000 +46 12 1502 1 5 5 -1 3 3 000000000000000000000000ff000000000000000000000000 +46 16 1502 1 5 6 0 4 5 0000000000000000000000ffff000000ffff000000000000000000000000 +46 24 1502 1 7 7 0 5 7 00000000000000000000000000000000ffffff00000000ffffff00000000ffffff00000000000000000000000000000000 +46 32 1502 1 7 8 1 6 9 00000000000000000000000000000000ffffff00000000ffffffff000000ffffffff000000ffffff00000000000000000000000000000000 +48 12 1341 1 9 12 -1 10 8 000000000000000000000000ffffff0000000000ffff0000ff00000000ff000000ffff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ffff0000ff0000000000ffffff000000000000000000000000000000000000000000 +48 16 1341 1 12 15 -1 13 10 0000000000000000000000000000000000ffff0000000000000000ffffffffffff000000000000ff00000000ff0000000000ffff00000000ffff00000000ffff0000000000ff00000000ff000000000000ff00000000ff000000000000ff00000000ff000000000000ff00000000ffff00000000ffff00000000ffff00000000ffff0000000000ffff0000ffff00000000000000ffffffff00000000000000000000000000000000000000000000000000000000 +48 24 1341 1 15 21 0 19 15 000000000000000000000000000000000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffffff000000ffffff000000000000ffff0000000000ffffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffffff0000ffffff0000000000000000ffff0000ffffff0000000000000000ffff0000ffffff0000000000000000ffff000000ffff00000000000000ffffff000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff0000000000ffffff0000000000ffff0000000000ffff00000000000000ffffffffffffffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000000000 +48 32 1341 1 20 27 0 25 20 0000000000000000000000000000000000000000000000000000000000ffff000000000000000000000000000000ffffffffffffffff0000000000000000000000ffffffffffffffffffff000000000000000000ffffffff00000000ffffffff0000000000000000ffffff000000000000ffffffff000000000000ffffff0000000000000000ffffff000000000000ffffff000000000000000000ffff0000000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff0000000000ffffff0000000000000000ffffff000000000000ffffff0000000000000000ffffff00000000000000ffffff000000000000ffffffff00000000000000ffffffffff0000ffffffffff000000000000000000ffffffffffffffffffff000000000000000000000000ffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +49 12 1342 1 6 11 -1 10 5 000000000000000000ffff000000ff00ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff0000000000ff00000000000000 +49 16 1342 1 8 14 -1 13 7 000000000000000000000000ffff0000000000ffffff00000000ffff00ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000ff00000000000000000000 +49 24 1342 1 9 20 0 19 10 00000000000000000000000000000000000000000000ffffffff000000ffffffffffff0000ffffff00ffffff0000ffff0000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff000000000000ffffff00000000000000000000 +49 32 1342 1 12 26 0 25 13 000000000000000000000000000000000000000000000000000000000000ffffffff000000000000ffffffffffff0000000000ffffffffffffff000000ffffffffff00ffffff000000ffffff000000ffffff000000ffff00000000ffffff000000ff0000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff000000000000000000ffffff0000000000000000000000000000 +56 12 1351 1 9 12 -1 10 7 000000000000000000000000ffffff0000000000ffff0000ff00000000ff000000ff00000000ff000000ff0000000000ffffff0000000000ff000000ff00000000ff00000000ff000000ff000000ffff00000000ffffffff0000000000000000000000000000000000000000 +56 16 1351 1 11 15 -1 13 10 000000000000000000000000000000ffffff00000000000000ffffffffffff00000000ffff00000000ff00000000ffff00000000ff0000000000ff00000000ff0000000000ffffffffff000000000000ffffffffffff00000000ffff00000000ffff000000ff0000000000ffff000000ffff00000000ffff000000ffff000000ffff0000000000ffffffffff00000000000000000000000000000000000000000000000000 +56 24 1351 1 15 21 0 19 15 000000000000000000000000000000000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffffff000000ffffff0000000000ffffff0000000000ffffff00000000ffff000000000000ffffff00000000ffff00000000000000ffff00000000ffffff0000000000ffff000000000000ffffff000000ffffff00000000000000ffffffffffffff00000000000000ffffffffffffffff000000000000ffffff0000000000ffff0000000000ffff00000000000000ffff00000000ffff00000000000000ffff000000ffffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff0000000000ffffff0000000000ffffffffffffffffff00000000000000ffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000 +56 32 1351 1 19 27 0 25 20 00000000000000000000000000000000000000000000000000000000ffff0000000000000000000000000000ffffffffffffffff000000000000000000ffffffffffffffffffffff0000000000000000ffffffff00000000ffffffff000000000000ffffff00000000000000ffffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff0000000000000000ffffff000000000000ffffff000000000000ffffff00000000000000ffffffff000000ffffffff00000000000000000000ffffffffffffffff00000000000000000000ffffffffffffffffffff0000000000000000ffffffff00000000ffffffff000000000000ffffff0000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff00000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff000000000000000000ffffffff00000000ffffff0000000000000000ffffff0000000000ffffffffff00000000ffffffffff000000000000ffffffffffffffffffffffff000000000000000000ffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +65 12 2 1 10 11 -1 10 8 0000000000000000000000000000ffff0000000000000000ffff0000000000000000ff00ff000000000000ff0000ff000000000000ff0000ff000000000000ff000000ff00000000ffffffffffff00000000ff00000000ff000000ffff0000000000ff0000000000000000000000 +65 16 2 1 13 14 -1 13 11 00000000000000000000000000000000000000ff0000000000000000000000ffffff00000000000000000000ff00ff000000000000000000ffff00ffff0000000000000000ffff00ffff0000000000000000ff000000ff00000000000000ffff000000ffff000000000000ffffffffffffff000000000000ffffffffffffff0000000000ffff0000000000ffff00000000ffff000000000000ff00000000ff00000000000000ff000000000000000000000000000000 +65 24 2 1 18 20 -1 19 17 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffff00ffff00000000000000000000000000ffff00ffff000000000000000000000000ffff0000ffff000000000000000000000000ffff000000ffff00000000000000000000ffffff000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffff0000000000000000ffffffffffffffffffffff00000000000000ffffffffffffffffffffff000000000000ffffff00000000000000ffff000000000000ffff0000000000000000ffffff0000000000ffff000000000000000000ffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffffff00000000000000000000000000000000000000 +65 32 2 1 24 26 -1 25 22 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0000000000000000000000000000000000000000ffffffff00000000000000000000000000000000000000ffffffffffff000000000000000000000000000000000000ffffffffffff000000000000000000000000000000000000ffff0000ffff0000000000000000000000000000000000ffffff0000ffffff00000000000000000000000000000000ffffff0000ffffff000000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff00000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff0000000000000000000000ffffff0000000000000000ffffff00000000000000000000ffffffffffffffffffffffffffff00000000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffff00000000000000000000ffffff0000000000000000ffffff00000000000000000000ffffff00000000000000ffffffff0000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff000000000000000000000000ffffff0000000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff0000000000000000000000000000000000000000000000000000 +66 12 65 1 9 11 0 10 8 00000000000000000000ffffffff0000000000ff000000ffff000000ff00000000ff000000ff000000ffff000000ffffffff0000000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ffffffffff000000000000000000000000 +66 16 65 1 11 14 0 13 10 000000000000000000000000ffffffffffff0000000000ffffffffffffff00000000ffff00000000ffff000000ffff0000000000ff000000ffff00000000ffff000000ffffffffffffff00000000ffffffffffffff00000000ffff0000000000ff000000ffff0000000000ffff0000ffff0000000000ff000000ffff00000000ffff000000ffffffffffffff0000000000000000000000000000 +66 24 65 1 15 20 1 19 16 00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffff0000000000ffffffffffffffffffffff00000000ffff00000000000000ffff00000000ffff00000000000000ffffff000000ffff00000000000000ffffff000000ffff00000000000000ffff00000000ffff000000000000ffffff00000000ffffffffffffffffffff0000000000ffffffffffffffffffff0000000000ffff000000000000ffffff00000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff00000000000000ffffff000000ffffffffffffffffffffff00000000ffffffffffffffffffff00000000000000000000000000000000000000 +66 32 65 1 20 26 1 25 21 000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000ffffffffffffffffffffffffff00000000000000ffffff00000000000000ffffffff000000000000ffffff0000000000000000ffffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffff0000000000ffffff00000000000000ffffffff000000000000ffffffffffffffffffffffff0000000000000000ffffffffffffffffffffffffff00000000000000ffffff000000000000ffffffffff000000000000ffffff000000000000000000ffffff0000000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff00000000000000000000ffffff00000000ffffff000000000000000000ffffffff00000000ffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffff000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000 +71 12 141 1 11 12 -1 10 9 000000000000000000000000000000ffffff00000000000000ff000000ff0000000000ff0000000000ff00000000ff00000000000000000000ff00000000000000000000ff000000ffffff00000000ff0000000000ff0000000000ff000000ffff0000000000ffffffffff00000000000000000000000000000000000000000000000000 +71 16 141 1 13 15 -1 13 12 000000000000000000000000000000000000ffffffff0000000000000000ffffffffffff000000000000ffff00000000ffff00000000ffff000000000000ffff000000ffff0000000000000000000000ff000000000000000000000000ff00000000ffffffffff000000ffff000000000000ffff000000ffff000000000000ffff00000000ff000000000000ff0000000000ffffff000000ffff00000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000 +71 24 141 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000000000000000000000ffffffffffffffff000000000000000000ffffffff0000ffffffff00000000000000ffffff000000000000ffffff0000000000ffffff0000000000000000ffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000000000000000ffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000ffffffffffff000000ffffff000000000000ffffffffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffff00000000ffffff000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffffffff0000000000ffffff00000000000000ffffffffffffffffffff00000000000000000000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000 +71 32 141 1 23 27 0 25 24 00000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000000000ffffffffffffffffff000000000000000000000000ffffffffffffffffffffffff00000000000000000000ffffffffff00000000ffffffffff0000000000000000ffffffff0000000000000000ffffffff000000000000ffffffff00000000000000000000ffffffff0000000000ffffff000000000000000000000000ffffff0000000000ffffff000000000000000000000000ffffffff000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000ffffffffffffffffff000000ffffff0000000000000000000000000000ffffff000000ffffff0000000000000000000000000000ffffff00000000ffffff00000000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff000000000000ffffff00000000000000000000ffffffff000000000000ffffffff0000000000000000ffffffff0000000000000000ffffffffffffff00ffffffffffff00000000000000000000ffffffffffffffffffffffff00000000000000000000000000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +79 12 321 1 11 12 -1 10 9 000000000000000000000000000000ffffff00000000000000ff000000ff0000000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff00000000ff0000000000ff0000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000 +79 16 321 1 14 15 -1 13 12 00000000000000000000000000000000000000ffffffff000000000000000000ffffffffffff00000000000000ffff00000000ffff0000000000ffff000000000000ffff00000000ffff00000000000000ff00000000ff0000000000000000ff00000000ff0000000000000000ff00000000ffff00000000000000ff00000000ffff000000000000ffff0000000000ff000000000000ffff0000000000ffffff0000ffffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000 +79 24 321 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000000000000000000000ffffffffffffffff000000000000000000ffffffff0000ffffffff00000000000000ffffff000000000000ffffff0000000000ffffff0000000000000000ffffff00000000ffff00000000000000000000ffff00000000ffff00000000000000000000ffffff000000ffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff0000ffffff0000000000000000000000ffff000000ffff0000000000000000000000ffff000000ffff00000000000000000000ffff00000000ffffff000000000000000000ffff0000000000ffff0000000000000000ffffff0000000000ffffffff0000000000ffffff00000000000000ffffffffffffffffffff00000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +79 32 321 1 24 27 0 25 24 0000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000ffffffffffffffffff00000000000000000000000000ffffffffffffffffffffffff0000000000000000000000ffffffffff00000000ffffffffffff0000000000000000ffffffff0000000000000000ffffffff0000000000000000ffffff00000000000000000000ffffffff000000000000ffffff000000000000000000000000ffffff000000000000ffffff00000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff000000000000000000000000000000ffff00000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffffff000000ffffff000000000000000000000000000000ffff00000000ffffff0000000000000000000000000000ffffff00000000ffffff0000000000000000000000000000ffffff0000000000ffffff00000000000000000000000000ffffff0000000000ffffff000000000000000000000000ffffff00000000000000ffffff00000000000000000000ffffffff00000000000000ffffffff0000000000000000ffffffff000000000000000000ffffffffffffff00ffffffffffff0000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +87 12 459 1 14 11 -1 10 12 000000000000000000000000000000ffff000000ffff000000ff00000000ff000000ffff000000ff00000000ff000000ffff000000ff00000000ff0000ff00ff000000ff00000000ffff00ff0000ff00ff000000000000ff00ff0000ff00ff000000000000ff00ff0000ff00ff000000000000ffff000000ff00ff00000000000000ff00000000ff000000000000000000000000000000000000 +87 16 459 1 18 14 -1 13 16 00000000000000000000000000000000000000ffff0000000000ffff0000000000ff00000000ff0000000000ffff0000000000ff00000000ff00000000ffffff00000000ffff00000000ffff000000ffffffff000000ff000000000000ff000000ff00ffff000000ff000000000000ff000000ff0000ff000000ff000000000000ffff00ffff0000ff0000ffff000000000000ffff00ffff0000ffff00ff0000000000000000ff00ff000000ffff00ff0000000000000000ff00ff00000000ff00ff0000000000000000ffffff00000000ffffff0000000000000000ffff0000000000ffff0000000000000000000000000000000000000000000000 +87 24 459 1 26 20 -1 19 24 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000000000ffffff00000000000000ffffff00000000ffff00000000000000ffffffff000000000000ffffff00000000ffffff000000000000ffffffff000000000000ffff000000000000ffff000000000000ffffffff000000000000ffff000000000000ffff0000000000ffff00ffff0000000000ffffff000000000000ffff0000000000ffff0000ffff00000000ffff0000000000000000ffff00000000ffff0000ffff00000000ffff0000000000000000ffff000000ffffff0000ffff00000000ffff0000000000000000ffff000000ffff000000ffff000000ffffff0000000000000000ffff000000ffff00000000ffff0000ffff00000000000000000000ffff0000ffff00000000ffff0000ffff00000000000000000000ffff00ffff0000000000ffff0000ffff00000000000000000000ffff00ffff0000000000ffff00ffff0000000000000000000000ffff00ffff000000000000ffffffff000000000000000000000000ffffffff000000000000ffffffff000000000000000000000000ffffff00000000000000ffffffff000000000000000000000000ffffff0000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000 +87 32 459 1 33 26 -1 25 32 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000000000ffffffff000000000000000000ffffffff000000ffffff00000000000000000000ffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffffffffff000000000000000000ffffff0000000000ffffff0000000000000000ffff00ffffff00000000000000ffffff000000000000ffffff0000000000000000ffff00ffffff00000000000000ffffff00000000000000ffffff000000000000ffffff00ffffff00000000000000ffffff00000000000000ffffff000000000000ffffff0000ffff00000000000000ffffff00000000000000ffffff000000000000ffffff0000ffffff0000000000ffffff0000000000000000ffffff0000000000ffffff000000ffffff0000000000ffffff000000000000000000ffffff00000000ffffff00000000ffff0000000000ffffff000000000000000000ffffff00000000ffffff00000000ffffff00000000ffff00000000000000000000ffffff00000000ffff0000000000ffffff000000ffffff0000000000000000000000ffff000000ffffff0000000000ffffff000000ffffff0000000000000000000000ffffff0000ffffff000000000000ffff000000ffffff0000000000000000000000ffffff0000ffffff000000000000ffffff0000ffff000000000000000000000000ffffff0000ffff00000000000000ffffff00ffffff00000000000000000000000000ffff00ffffff00000000000000ffffff00ffffff00000000000000000000000000ffffffffffff0000000000000000ffff00ffffff00000000000000000000000000ffffffffffff0000000000000000ffff00ffff0000000000000000000000000000ffffffffff000000000000000000ffffffffff000000000000000000000000000000ffffffff000000000000000000ffffffffff000000000000000000000000000000ffffffff00000000000000000000ffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000 +97 12 507 1 8 10 -1 8 7 0000000000000000000000ffff0000000000ff0000ffff00000000000000ff00000000ffffffff000000ff000000ff000000ff0000ffff000000ffffff00ff0000000000000000000000000000000000 +97 16 507 1 10 12 -1 10 9 0000000000000000000000000000ffffff0000000000ffffff00ffff000000000000000000ffff0000000000000000ffff00000000ffffffffffff000000ffff000000ffff000000ff00000000ffff000000ffff0000ffffff00000000ffffffffffff000000000000000000000000000000000000000000 +97 24 507 1 13 17 0 15 13 000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000ffffffffffffffffff00000000ffff0000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000ffffffffffff000000ffffffffffffff00ffff0000ffffffff0000000000ffff0000ffff000000000000ffffff0000ffff000000000000ffffff0000ffffff0000000000ffffff000000ffffffffffffff00ffff00000000ffffffffff0000ffff000000000000000000000000000000000000000000000000000000 +97 32 507 1 17 21 0 19 18 000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff0000000000ffffffff000000000000ffffff00000000ffffff00000000000000ffffff000000000000000000000000000000ffff000000000000000000000000000000ffff00000000000000000000000000ffffffff00000000000000ffffffffffffffffffff0000000000ffffffffffffffffff00ffff00000000ffffffffff000000000000ffff00000000ffffff0000000000000000ffff000000ffffff000000000000000000ffff000000ffffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff00000000ffffffffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffffff0000ffff000000000000000000000000000000000000000000000000000000000000000000000000 +98 12 578 1 9 12 -1 10 7 0000000000000000000000ff0000000000000000ff0000000000000000ff00ffff0000000000ffff0000ff00000000ff000000ffff000000ff00000000ff000000ff00000000ff000000ff000000ff00000000ffffffffff0000000000000000000000000000000000000000 +98 16 578 1 10 15 0 13 10 0000000000000000000000ffff0000000000000000ffff0000000000000000ffff0000000000000000ffff00ffffff00000000ffffffff00ffff000000ffff00000000ffff0000ffff00000000ffff0000ffff0000000000ff0000ffff00000000ffff0000ffff00000000ffff0000ffffff0000ffff000000ffffffffffff0000000000000000000000000000000000000000000000 +98 24 578 1 15 21 0 19 15 0000000000000000000000000000000000000000000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00000000000000000000000000ffff00ffffffffffff000000000000ffffffffffffffffffff0000000000ffffff0000000000ffffff00000000ffffff000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffff00000000000000ffff00000000ffffff000000000000ffff00000000ffffff0000000000ffffff00000000ffffffffffffffffffff0000000000ffff00ffffffffffff00000000000000000000000000000000000000000000000000000000000000000000 +98 32 578 1 18 27 1 25 20 00000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff00000000ffffff0000000000000000ffffff0000ffffffffffffffff0000000000ffffff00ffffffffffffffffffff00000000ffffffffffff0000000000ffffff00000000ffffffffff00000000000000ffffff000000ffffffff0000000000000000ffffff000000ffffffff000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffff00000000000000000000ffffff0000ffffffff000000000000000000ffffff0000ffffffff0000000000000000ffffff000000ffffffffff000000000000ffffffff000000ffffff00ffff00000000ffffffff00000000ffffff00ffffffffffffffffff0000000000ffffff0000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000 +103 12 658 1 9 12 -1 8 7 00000000000000000000000000ff00ff00000000ffff00ffff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff0000000000ffffffff0000000000000000ff00000000ffff00ffff000000000000ff00000000000000000000000000 +103 16 658 1 11 15 -1 10 10 000000000000000000000000000000ffffff00ffff00000000ffff00ffffffff000000ffff00000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ffff00000000ffff00000000ffff00ffffffff0000000000ffffff00ffff000000000000000000ffff000000ffff00000000ff0000000000ffffffffffff000000000000000000000000000000000000000000000000 +103 24 658 1 14 22 0 15 15 0000000000000000000000000000000000000000000000000000000000000000ffffffffff0000ffff00000000ffffffffffffff00ffff000000ffffff00000000ffffffff000000ffff000000000000ffffff0000ffffff00000000000000ffff0000ffff0000000000000000ffff0000ffff0000000000000000ffff0000ffff0000000000000000ffff0000ffffff000000000000ffffff000000ffff000000000000ffffff000000ffffff00000000ffffffff00000000ffffffffffffff00ffff000000000000ffffff000000ffff000000000000000000000000ffff00000000ff00000000000000ffff000000ffff000000000000ffff0000000000ffffffffffffffffff000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000 +103 32 658 1 19 27 0 19 20 0000000000000000000000000000000000000000000000000000ffffffff00000000000000000000000000ffffffffffffffff00ffffff000000000000ffffffffffffffffffffffffff0000000000ffffffff0000000000ffffffffff0000000000ffffff00000000000000ffffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffffff00000000000000ffffffff0000000000ffffffff0000000000ffffffffff000000000000ffffffffffffffffffffffffff00000000000000ffffffffffffffff00ffffff000000000000000000ffffffff000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffff000000000000ff000000000000000000ffffff00000000ffffffff00000000000000ffffff000000000000ffffffffffffffffffffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffff00000000000000000000000000000000000000000000000000 +109 12 766 1 12 9 -1 8 11 0000000000000000000000000000ff00ffff0000ff0000000000ffff00ff000000ff00000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff000000ff00000000000000000000000000 +109 16 766 1 14 11 0 10 14 000000000000000000000000000000ffff00ffff000000ffff00000000ffffff00ffff00ff00ffff000000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff0000ffff000000ffff000000ffff000000000000000000000000000000 +109 24 766 1 21 16 0 15 21 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00ffffffffff0000ffffffffffff0000000000ffffffffffffffffffffffffffffffffff00000000ffffff00000000ffffff00000000ffffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff00000000ffff0000000000ffffff0000000000ffff0000000000000000000000000000000000000000000000 +109 32 766 1 26 20 1 19 28 000000000000000000000000000000000000000000000000000000000000000000ffffffff000000000000ffffffff000000000000ffffff0000ffffffffffff000000ffffffffffffffff00000000ffffff00ffffffffffffffff00ffffffffffffffffffff000000ffffffffff00000000ffffff00ffff0000000000ffffff000000ffffffff000000000000ffffffff000000000000ffffff000000ffffff0000000000000000ffffff00000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff0000ffffff0000000000000000ffff0000000000000000ffffff000000000000000000000000000000000000000000000000000000 +111 12 790 1 9 10 -1 8 7 00000000000000000000000000ff000000000000ffff00ffff00000000ff000000ff00000000ff000000ffff000000ff000000ffff000000ff000000ff0000000000ffffff000000000000000000000000000000000000000000 +111 16 790 1 11 12 -1 10 10 000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff0000000000ffff000000ff0000000000ffff000000ff0000000000ffff000000ffff00000000ff0000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000 +111 24 790 1 15 17 0 15 14 00000000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000000000ffffffffffffffff000000000000ffffff0000000000ffff0000000000ffff000000000000ffffff000000ffffff00000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffff0000000000000000ffff000000ffffff00000000000000ffff00000000ffff000000000000ffffff00000000ffffff0000000000ffff000000000000ffffffffffffffff0000000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000 +111 32 790 1 19 21 0 19 19 000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffff000000000000000000ffffffffffffffffffffff00000000000000ffffffff0000000000ffffffff000000000000ffffff00000000000000ffffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff00000000000000000000ffff00000000ffffff00000000000000000000ffffff000000ffff0000000000000000000000ffffff000000ffffff00000000000000000000ffffff000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff0000000000ffffff00000000000000ffffff00000000000000ffffffff00000000ffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +115 12 871 1 8 10 -1 8 6 0000000000000000000000ffff0000000000ff0000ff00000000ff00000000000000ffffff0000000000000000ffff000000ff000000ff000000ffffffff000000000000000000000000000000000000 +115 16 871 1 10 12 -1 10 8 0000000000000000000000000000ffffff0000000000ffffff00ffff00000000ffff000000ff00000000ffff000000000000000000ffffffff000000000000000000ffff000000000000000000ffff000000ffff000000ff0000000000ffffffffff00000000000000000000000000000000000000000000 +115 24 871 1 13 17 0 15 13 000000000000000000000000000000000000000000000000000000000000ffffffffff000000000000ffffffffffffffff0000000000ffff0000000000ffff00000000ffff0000000000000000000000ffff0000000000000000000000ffffffffff00000000000000000000ffffffffffff00000000000000000000ffffffff0000000000000000000000ffff0000000000000000000000ffff000000ffffff0000000000ffff00000000ffffffffffffffffff0000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000 +115 32 871 1 17 21 0 19 17 000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff000000000000ffffff0000000000ffffffff00000000ffffff00000000000000ffffff00000000ffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffffffff00000000000000000000000000ffffffffffffffff0000000000000000000000ffffffffffffffff000000000000000000000000ffffffffffff0000000000000000000000000000ffffffff0000000000000000000000000000ffffff0000000000ffff00000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff0000000000ffffffff0000000000ffffffffffffffffffffff00000000000000ffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000 +119 12 984 1 12 9 -1 8 10 00000000000000000000000000ffff0000ff000000ff00000000ff0000ffff0000ff00000000ff0000ffff0000ff00000000ff000000ff00ff000000000000ffff0000ffff000000000000ffff0000ffff000000000000ffff0000ffff000000000000000000000000000000 +119 16 984 1 15 11 -1 10 13 0000000000000000000000000000000000ff00000000ff00000000ff00000000ff000000ffffff000000ff00000000ffff0000ff00ff0000ffff0000000000ff0000ff00ff0000ffff0000000000ff0000ff00ff0000ff000000000000ff00ffff00ffff00ff000000000000ffffff000000ffffff00000000000000ffff000000ffff0000000000000000ffff000000ffff00000000000000000000000000000000000000 +119 24 984 1 21 16 -1 15 20 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff0000000000ffffff000000ffffff00000000ffffff0000000000ffff0000000000ffff00000000ffffffff00000000ffff0000000000ffff00000000ffffffff00000000ffff0000000000ffff000000ffff00ffff000000ffff00000000000000ffff0000ffff0000ff000000ffff00000000000000ffff0000ffff0000ffff0000ffff00000000000000ffff0000ff000000ffff00ffffff00000000000000ffff00ffff000000ffff00ffff000000000000000000ffffffff00000000ff00ffff000000000000000000ffffffff00000000ffffffff000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffff0000000000000000000000000000000000000000000000000000 +119 32 984 1 27 20 0 19 26 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000ffffffff00000000000000ffffff00000000ffffff000000000000ffffffff00000000000000ffff0000000000ffffff000000000000ffffffff000000000000ffffff0000000000ffffff000000000000ffffffffff0000000000ffffff000000000000ffff0000000000ffffff00ffff0000000000ffffff000000000000ffffff00000000ffff0000ffff00000000ffffff00000000000000ffffff00000000ffff0000ffffff000000ffffff0000000000000000ffff000000ffffff0000ffffff000000ffffff0000000000000000ffffff0000ffffff000000ffff000000ffff000000000000000000ffffff0000ffff00000000ffff0000ffffff000000000000000000ffffff0000ffff00000000ffffff00ffffff00000000000000000000ffff00ffffff00000000ffffff00ffff0000000000000000000000ffffffffff000000000000ffff00ffff0000000000000000000000ffffffffff000000000000ffffffffff000000000000000000000000ffffffff000000000000ffffffffff000000000000000000000000ffffffff00000000000000ffffff00000000000000000000000000ffffff0000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000 +122 12 1022 1 8 9 -1 8 7 00000000000000000000ffffffffff000000000000ffff000000000000ff000000000000ff000000000000ff000000000000ffff000000000000ffffffffff000000000000000000 +122 16 1022 1 10 11 -1 10 9 000000000000000000000000ffffffffffffff000000ffffffffffffff00000000000000ffff00000000000000ffff0000000000000000ff0000000000000000ffff00000000000000ffff00000000000000ffff0000000000000000ffffffffffffff0000000000000000000000 +122 24 1022 1 13 16 0 15 13 00000000000000000000000000000000000000000000000000000000ffffffffffffffffffff000000ffffffffffffffffffff000000000000000000ffffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffffff000000000000000000ffffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffff00000000000000000000ffffff000000000000000000ffffffffffffffffffffff0000ffffffffffffffffffffff0000000000000000000000000000 +122 32 1022 1 17 20 0 19 18 000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff0000000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffff000000000000000000000000000000000000 +35 12 1453 1 10 11 -1 10 8 00000000000000000000000000ff000000000000000000ff0000ff000000000000ff0000ff0000000000ffffffffffff0000000000ff0000ff000000000000ff0000ff00000000ffffffffffffff00000000ff0000ff000000000000ff0000ff0000000000000000000000000000 +35 16 1453 1 12 14 -1 13 10 00000000000000000000000000000000ffff0000ffff000000000000ff000000ff00000000000000ff000000ff00000000000000ff000000ff0000000000ffffffffffffffffff0000000000ff000000ff000000000000ffff0000ffff000000000000ff000000ff0000000000ffffffffffffffffff0000000000ff000000ff00000000000000ff000000ff00000000000000ff000000ff00000000000000000000000000000000 +35 24 1453 1 17 20 -1 19 15 00000000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff00000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff00000000000000ffffffffffffffffffffffffff00000000ffffffffffffffffffffffffff000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ff0000000000ffff0000000000000000ffff0000000000ff000000000000000000ffff00000000ffff0000000000000000000000000000000000000000000000 +35 32 1453 1 22 26 -1 25 20 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff0000000000000000000000ffffff000000000000ffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffff0000000000000000ffffffffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff0000000000000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffffff0000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff000000000000000000000000ffff000000000000ffff0000000000000000000000ffffff000000000000ffff0000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000000000000000000000000000000000000000 +37 12 1744 1 12 12 0 10 12 0000000000000000000000000000ffff00000000ff00000000ff0000ff000000ff00000000ff0000ff0000ff000000000000ffff0000ff00000000000000000000ff0000000000000000000000ff0000ffff000000000000ff0000ff00ff0000000000ff000000ff00000000000000ff000000ffffff0000000000000000000000000000000000000000000000000000 +37 16 1744 1 15 15 0 13 16 000000000000000000000000000000000000ffff000000000000ff0000000000ff0000ff00000000ffff0000000000ff0000ff00000000ff000000000000ff0000ff000000ff00000000000000ffffffff0000ffff00000000000000000000000000ff00000000000000000000000000ff00000000000000000000000000ffff0000ffffff0000000000000000ff0000ffff0000ff000000000000ff000000ffff0000ff0000000000ffff000000ffff0000ff00000000ffff0000000000ffffff0000000000000000000000000000000000000000000000000000000000000000 +37 24 1744 1 21 21 1 19 24 00000000000000000000000000000000000000000000000000ffff0000000000000000000000000000000000ffffffffffff00000000000000ffff000000000000ffff0000ffff000000000000ffff00000000000000ffff000000ffff0000000000ffff00000000000000ff00000000ffff00000000ffff0000000000000000ffff000000ff00000000ffff000000000000000000ffff0000ffff00000000ffff00000000000000000000ffffffff00000000ffff000000000000000000000000000000000000ffff00000000000000000000000000000000000000ffff000000000000000000000000000000000000ffff00000000ffffff0000000000000000000000ffff00000000ffffffffff00000000000000000000ff00000000ffff000000ffff0000000000000000ffff00000000ffff000000ffff00000000000000ffff0000000000ffff000000ffff000000000000ffff000000000000ffff000000ffff000000000000ffff000000000000ffffff00ffff000000000000ffff0000000000000000ffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +37 32 1744 1 27 27 2 25 31 0000000000000000000000000000000000000000000000000000000000000000ffff0000000000000000000000000000000000000000000000ffffffffffff0000000000000000000000ffff00000000000000ffffffff00ffffff000000000000000000ffffff00000000000000ffff00000000ffff0000000000000000ffffff0000000000000000ffff00000000ffffff00000000000000ffff000000000000000000ffff00000000ffffff000000000000ffffff000000000000000000ffff00000000ffffff0000000000ffffff00000000000000000000ffff00000000ffffff0000000000ffff0000000000000000000000ffffff0000ffffff0000000000ffffff000000000000000000000000ffffffffffffff00000000ffffff0000000000000000000000000000ffffffff000000000000ffff000000000000000000000000000000000000000000000000ffffff0000000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000000000000000ffff000000000000000000000000000000000000000000000000ffff000000000000ffffffffff00000000000000000000000000ffffff0000000000ffffffffffffff0000000000000000000000ffffff0000000000ffffff000000ffff0000000000000000000000ffff000000000000ffff00000000ffffff000000000000000000ffffff000000000000ffff00000000ffffff0000000000000000ffffff00000000000000ffff00000000ffffff0000000000000000ffff0000000000000000ffff00000000ffffff00000000000000ffffff0000000000000000ffffff000000ffffff000000000000ffffff00000000000000000000ffffffffffffff00000000000000ffff0000000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +38 12 1425 1 10 12 -1 10 8 00000000000000000000000000ffffff000000000000ffff00ff000000000000ff0000ffff000000000000ffffff00000000000000ffff00000000000000ff00ffff00ff00000000ff0000ff00ff00000000ff000000ff0000000000ffffffff00ff00000000000000000000000000000000000000000000 +38 16 1425 1 13 15 -1 13 10 0000000000000000000000000000000000ffffff000000000000000000ffff00ffff0000000000000000ff000000ff0000000000000000ff000000ff0000000000000000ffff00ffff000000000000000000ffffff000000000000000000ffffffff0000000000000000ffff0000ff0000ff0000000000ff000000ffff00ff0000000000ff00000000ffffff0000000000ffff000000ffffff000000000000ffffffffff00ffff00000000000000000000000000000000000000000000000000000000 +38 24 1425 1 17 21 0 19 15 0000000000000000000000000000000000000000000000ffff00000000000000000000000000ffffffffffff00000000000000000000ffffff0000ffffff000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ffff00000000ffff000000000000000000ffffff00ffffff0000000000000000000000ffffffffff00000000000000000000000000ffffff000000000000000000000000ffffffffff0000000000000000000000ffffff00ffffff000000ffff0000000000ffff000000ffffff0000ffff00000000ffffff00000000ffffff00ffff00000000ffff000000000000ffffffff0000000000ffffff000000000000ffffff000000000000ffff0000000000ffffffff000000000000ffffffffffffffffffffffff00000000000000ffffffffffff0000ffffff000000000000000000000000000000000000000000000000000000000000000000000000 +38 32 1425 1 22 27 0 25 21 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff0000000000000000000000000000ffffffffffffffffff000000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff0000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffff000000000000ffffff0000000000000000000000ffffff00000000ffffff000000000000000000000000ffffff000000ffffffff00000000000000000000000000ffffff00ffffffff0000000000000000000000000000ffffffffffffff00000000000000000000000000000000ffffffffff00000000000000000000000000000000ffffffffffff000000000000000000000000000000ffffffffffffff0000000000000000000000000000ffffffff0000ffffff00000000ffffff0000000000ffffffff00000000ffffff000000ffffff0000000000ffffff0000000000ffffffff0000ffff000000000000ffffff000000000000ffffffffffffff000000000000ffffff00000000000000ffffffffffff000000000000ffffff0000000000000000ffffffff00000000000000ffffff0000000000000000ffffffff0000000000000000ffffffff00000000ffffffffffffff0000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff000000ffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +63 12 1431 1 8 12 -1 10 6 0000000000000000000000ffff0000000000ff0000ff00000000000000ffff000000000000ff000000000000ff000000000000ff0000000000000000000000000000000000000000000000ffff00000000000000000000000000000000000000 +63 16 1431 1 10 15 -1 13 8 0000000000000000000000000000ffffff0000000000ffffffffffff00000000ff00000000ff000000000000000000ff0000000000000000ffff00000000000000ffff00000000000000ffff0000000000000000ffff00000000000000000000000000000000000000000000000000000000ffff0000000000000000ffff000000000000000000000000000000000000000000000000 +63 24 1431 1 14 21 -1 19 12 0000000000000000000000000000000000000000ffffff000000000000000000ffffffffffffff000000000000ffffff0000ffffff0000000000ffffff0000000000ffff00000000ffff000000000000ffff000000000000000000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000000000ffffff00000000000000000000ffffff0000000000000000000000ffff000000000000000000000000ffff0000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000ffffff0000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000 +63 32 1431 1 16 27 0 25 16 0000000000000000000000000000000000000000000000ffff0000000000000000000000ffffffffffffffff00000000000000ffffffffffffffffffff0000000000ffffffff00000000ffffffff00000000ffffff000000000000ffffff000000ffffff0000000000000000ffffff0000ffffff0000000000000000ffffff00000000000000000000000000ffffff000000000000000000000000ffffff00000000000000000000000000ffffff0000000000000000000000ffffffff0000000000000000000000ffffffff0000000000000000000000ffffffff0000000000000000000000ffffffff000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000ffffffff000000000000000000000000ffffffff00000000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000 +233 12 618 1 9 13 -1 11 7 0000000000000000000000000000000000000000000000ff00000000000000ff0000000000000000ff000000000000ffff00ffff00000000ff000000ff00000000ffffffffff00000000ff0000000000000000ff000000ff0000000000ffffffff0000000000000000000000000000000000000000 +233 16 618 1 11 16 -1 14 9 00000000000000000000000000000000000000000000000000000000ff000000000000000000ffff00000000000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff0000000000ff00000000ffffffffffffffff000000ff00000000000000000000ffff00000000000000000000ff000000ffff000000000000ffffffff00000000000000000000000000000000000000000000000000 +233 24 618 1 14 22 0 20 14 0000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000000000000000ffff0000000000000000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffffffffffffff0000000000ffffff00000000ffffff00000000ffff000000000000ffff000000ffffff00000000000000ffff0000ffffffffffffffffffffffff0000ffffffffffffffffffffffff0000ffff000000000000000000000000ffffff000000000000000000000000ffff000000000000000000000000ffffff0000000000ffff0000000000ffffffffffffffffff000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000000000 +233 32 618 1 19 28 0 26 19 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000ffffffffffffffffff000000000000000000ffffffffffffffffffffff00000000000000ffffffff0000000000ffffffff000000000000ffffff00000000000000ffffff0000000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffff000000000000000000ffffff00000000ffffffffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffff00000000ffff0000000000000000000000000000000000ffffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffff000000000000000000ff00000000000000ffffff00000000000000ffffffff000000000000ffffffff00000000ffffffff00000000000000ffffffffffffffffffffff00000000000000000000ffffffffffffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +224 12 528 1 8 13 -1 11 7 00000000000000000000000000000000000000ff0000000000000000ff000000000000ffff0000000000ff0000ffff00000000000000ff00000000ffffffff000000ff000000ff000000ff0000ffff000000ffffff00ff0000000000000000000000000000000000 +224 16 528 1 10 16 -1 14 9 000000000000000000000000000000000000000000000000ff000000000000000000ffff000000000000000000000000000000000000ffffff0000000000ffffff00ffff000000000000000000ffff0000000000000000ffff00000000ffffffffffff000000ffff000000ffff000000ff00000000ffff000000ffff0000ffffff00000000ffffffffffff000000000000000000000000000000000000000000 +224 24 528 1 13 22 0 20 13 000000000000000000000000000000000000000000000000000000000000ffff000000000000000000000000ffff0000000000000000000000ffff000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000ffffffffffffffffff00000000ffff0000000000ffff0000000000000000000000ffffff00000000000000000000ffffff00000000000000ffffffffffff000000ffffffffffffff00ffff0000ffffffff0000000000ffff0000ffff000000000000ffffff0000ffff000000000000ffffff0000ffffff0000000000ffffff000000ffffffffffffff00ffff00000000ffffffffff0000ffff000000000000000000000000000000000000000000000000000000 +224 32 528 1 17 28 0 26 18 000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000000000000000ffffff0000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffff00000000000000000000ffffffffffffffffff00000000000000ffffffffffffffffffffff0000000000ffffffff000000000000ffffff00000000ffffff00000000000000ffffff000000000000000000000000000000ffff000000000000000000000000000000ffff00000000000000000000000000ffffffff00000000000000ffffffffffffffffffff0000000000ffffffffffffffffff00ffff00000000ffffffffff000000000000ffff00000000ffffff0000000000000000ffff000000ffffff000000000000000000ffff000000ffffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffffff00000000ffffffffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffffff0000ffff000000000000000000000000000000000000000000000000000000000000000000000000 +231 12 589 1 9 12 -1 8 7 00000000000000000000000000ffff0000000000ffff00ffff00000000ff0000000000000000ff0000000000000000ff0000000000000000ff000000ff0000000000ffffff00000000000000ff000000000000000000ff000000000000000000000000000000000000000000 +231 16 589 1 11 15 -1 10 9 000000000000000000000000000000ffffff00000000000000ffff00ffffff00000000ffff00000000ff00000000ff00000000000000000000ff00000000000000000000ff00000000000000000000ffff00000000ff0000000000ff000000ffff000000000000ffffffff0000000000000000ff0000000000000000000000ffff0000000000000000ffffff00000000000000000000000000000000000000000000000000 +231 24 589 1 14 21 0 15 14 0000000000000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffffffffffffff0000000000ffffff0000000000ffff00000000ffff000000000000ffff000000ffffff0000000000000000000000ffff000000000000000000000000ffff000000000000000000000000ffff000000000000000000000000ffffff000000000000000000000000ffff000000000000ffff00000000ffffff0000000000ffff0000000000ffffffffffffffff00000000000000ffffffffffff0000000000000000000000ff000000000000000000000000ffffff00000000000000000000000000ffff000000000000000000000000ffff00000000000000000000ffffff00000000000000000000000000000000000000 +231 32 589 1 18 27 0 19 18 0000000000000000000000000000000000000000000000000000ffffff000000000000000000000000ffffffffffffffffff0000000000000000ffffffffffffffffffffff000000000000ffffffff0000000000ffffffff0000000000ffffff00000000000000ffffff00000000ffffff000000000000000000ff0000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffff00000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000000000000000ffffff000000000000000000ffffff00000000ffffff00000000000000ffffff000000000000ffffffff00000000ffffffff000000000000ffffffffffffffffffffff000000000000000000ffffffffffffff0000000000000000000000000000ff0000000000000000000000000000000000ffff000000000000000000000000000000ffffffffff00000000000000000000000000000000ffff00000000000000000000000000000000ffff00000000000000000000000000ffffffffff00000000000000000000000000ffff0000000000000000000000000000000000000000000000000000 +252 12 916 1 9 13 -1 11 7 000000000000000000000000000000000000000000ff00ff0000000000000000000000000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff00000000ff000000ff0000000000ffffffff0000000000000000000000000000000000000000 +252 16 916 1 10 16 0 14 9 00000000000000000000000000000000000000000000ffff0000ff0000000000ffff0000ff0000000000000000000000000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff000000ffff00000000ff00000000ffff0000ffff00000000ffffffff00ff00000000000000000000000000000000000000000000 +252 24 916 1 14 22 0 20 14 0000000000000000000000000000000000000000000000000000000000000000ffff0000ffffff000000000000ffffff0000ffffff00000000000000ff00000000ff00000000000000000000000000000000000000000000000000000000000000000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffff000000000000ffff00000000ffffff00000000ffffff0000000000ffffffffffffffffff000000000000ffffffffff00ffff000000000000000000000000000000000000000000000000000000000000 +252 32 916 1 17 28 1 26 19 0000000000000000000000000000000000000000000000000000000000000000000000000000ffff00000000ffffff00000000000000ffffffff000000ffffffff000000000000ffffffff000000ffffff0000000000000000ffff0000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff000000ffffff000000000000000000ffff00000000ffff0000000000000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000000000ffffffff00000000ffffffffff000000ffff00ffff0000000000ffffffffffffffffff00ffff000000000000ffffffffffff000000ffff000000000000000000000000000000000000000000000000000000000000000000000000 +216 12 324 1 11 12 -1 10 9 000000000000000000000000000000ffffff00ff0000000000ff000000ff0000000000ff00000000ffff00000000ff000000ff00ff00000000ff0000ff0000ff00000000ff00ffff0000ff00000000ff00ff000000ff0000000000ff000000ffff00000000ff00ffffffff00000000000000000000000000000000000000000000000000 +216 16 324 1 14 15 -1 13 12 00000000000000000000000000000000000000ffffffff00ff00000000000000ffffffffffffff000000000000ffff00000000ffff0000000000ffff00000000ffffffff00000000ffff00000000ff0000ff00000000ff00000000ff000000ff00000000ff000000ffff000000ff00000000ffff00ffff00000000ff00000000ffff00ff00000000ffff0000000000ffffff00000000ffff0000000000ffffff0000ffffff000000000000ff00ffffffffff0000000000000000000000000000000000000000000000000000000000000000 +216 24 324 1 18 21 0 19 18 00000000000000000000000000000000000000000000000000ffffffff000000ff0000000000000000ffffffffffffffffffffff000000000000ffffffff0000ffffffffff000000000000ffffff000000000000ffffff0000000000ffffff000000000000ffffffffff00000000ffff00000000000000ffff00ffff00000000ffff000000000000ffff0000ffffff000000ffff0000000000ffffff000000ffff0000ffffff0000000000ffff00000000ffff0000ffffff00000000ffff0000000000ffff0000ffffff000000ffff000000000000ffff000000ffff000000ffff000000000000ffff000000ffff0000ffff000000000000ffff00000000ffffffffff00000000000000ffff0000000000ffffffff000000000000ffffff0000000000ffffffff0000000000ffffff000000000000ffffffffffffffffffffff000000000000ffffff00ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +216 32 324 1 24 27 0 25 24 0000000000000000000000000000000000000000000000000000000000000000000000ffffff0000000000ff000000000000000000000000ffffffffffffffffff00ffffff000000000000000000ffffffffffffffffffffffffffffff0000000000000000ffffffffff00000000ffffffffffff0000000000000000ffffffff0000000000000000ffffffff0000000000000000ffffff000000000000000000ffffffffff000000000000ffffff000000000000000000ffffffffffff000000000000ffffff0000000000000000ffffff0000ffffff00000000ffffff0000000000000000ffffff000000ffffff00000000ffffff0000000000000000ffffff000000ffffff00000000ffffff00000000000000ffffff0000000000ffff00000000ffffff000000000000ffffff000000000000ffffff000000ffffff000000000000ffffff000000000000ffffff000000ffffff0000000000ffffff00000000000000ffffff000000ffffff00000000ffffff0000000000000000ffff00000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff0000000000000000ffffff0000000000ffffff00ffffff000000000000000000ffffff0000000000ffffffffffff000000000000000000ffffff00000000000000ffffffffff0000000000000000ffffffff00000000000000ffffffff0000000000000000ffffffff0000000000000000ffffffffffffffff00ffffffffffff000000000000000000ffffffffffffffffffffffffffff000000000000000000ffffff0000ffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +64 12 1445 1 13 14 -1 10 12 000000000000000000000000000000000000000000000000000000000000ffff0000ffff000000000000ff000000000000ff00000000ff0000ffffffff0000ff000000ff0000ff0000ff0000ff000000ff00ff000000ff0000ff000000ff00ff000000ff0000ff000000ff0000ff0000ff0000ff000000ff000000ffff00ffff0000000000ff00000000000000000000000000ffffffffffff0000000000000000000000000000000000000000000000000000000000 +64 16 1445 1 17 18 -1 13 15 000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff000000000000000000ffff000000000000ffff000000000000ffff0000000000000000ff000000000000ff000000ffffff00ff0000ff00000000ffff0000ffff0000ffff0000ff00000000ff000000ff000000ffff0000ff00000000ff0000ffff00000000ff0000ff00000000ff0000ffff00000000ff0000ff00000000ff000000ff000000ffff0000ff00000000ffff0000ffff00ffffff00ffff0000000000ff000000ffffff0000ffff000000000000ffff00000000000000000000000000000000ffffff00000000000000000000000000000000ffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000 +64 24 1445 1 23 24 0 18 23 0000000000000000000000000000000000000000000000000000000000000000ffffffffffff0000000000000000000000000000ffffffffffffffffffffff0000000000000000000000ffffff00000000000000ffffffff0000000000000000ffffff00000000000000000000ffffff000000000000ffff00000000000000000000000000ffff000000000000ffff0000000000ffffff000000000000ffff00000000ffff00000000ffffffffffffffff000000ffff00000000ffff000000ffffff000000ffffff00000000ffff000000ffff000000ffff0000000000ffff00000000ffff0000ffff00000000ff000000000000ffff00000000ffff0000ffff000000ffff000000000000ffff00000000ffff0000ffff00000000ff000000000000ffff00000000ffff000000ff00000000ffff0000000000ffff00000000ffff000000ffff000000ffff0000000000ffff00000000ff00000000ffff000000ffffff000000ffffffff0000ffff00000000ffff00000000ffffffffffff00ffffffffff000000000000ffff000000000000ff0000000000ffff00000000000000ffffff000000000000000000000000000000000000000000ffffff000000000000000000000000000000000000000000ffffffff000000000000ffff00000000000000000000000000ffffffffffffffffffff00000000000000000000000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000 +64 32 1445 1 30 32 0 24 31 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffff0000000000000000000000000000000000ffffffffffffffffffffffffffffff0000000000000000000000000000ffffffff000000000000000000ffffffffff00000000000000000000ffffffff00000000000000000000000000ffffffff000000000000000000ffffff000000000000000000000000000000ffffffff00000000000000ffffff0000000000000000000000000000000000ffffff000000000000ffffff0000000000000000ffffff0000000000000000ffffff0000000000ffffff0000000000ffffffffffffffffffffff00000000ffff0000000000ffff0000000000ffffffffffffffffffffffff00000000ffffff000000ffffff0000000000ffffff0000000000ffffffff00000000ffffff000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff0000000000ffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffff0000000000000000ffffff00000000ffffff000000ffffff00000000ffffff00000000000000ffffff00000000ffffff000000ffffff00000000ffffff000000000000ffffffff00000000ffff00000000ffffff0000000000ffffff00000000ffffffffff000000ffffff0000000000ffff0000000000ffffffffffffffffff00ffffffffffffffff0000000000ffffff000000000000ffffffffffff0000ffffffffffffff00000000000000ffffff00000000000000000000000000000000ff00000000000000000000ffffff00000000000000000000000000000000000000000000000000000000ffffff00000000000000000000000000000000000000000000000000000000ffffffff000000000000000000000000000000000000000000000000000000ffffffffffff00000000000000ffffff000000000000000000000000000000ffffffffffffffffffffffffffffff000000000000000000000000000000000000ffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 diff --git a/test/oracle/main.cpp b/test/oracle/main.cpp new file mode 100644 index 0000000..487febb --- /dev/null +++ b/test/oracle/main.cpp @@ -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(sys.scratch.peak())); + err_write(" / "); + err_write_i64(static_cast(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 diff --git a/test/oracle/oracle.cpp b/test/oracle/oracle.cpp new file mode 100644 index 0000000..a2e7f4f --- /dev/null +++ b/test/oracle/oracle.cpp @@ -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((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(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(begin)); + err_write(".."); + err_write_i64(static_cast(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(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(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(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(c.seed)); + err_write(" in_len="); + err_write_i64(static_cast(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(ref_len)); + err_write(" optimisee="); + err_write_i64(static_cast(opt_len)); + err_write("\n"); + if (diff_at < ref_len) { + err_write(" premier octet divergent a l offset "); + err_write_i64(static_cast(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 diff --git a/test/oracle/oracle.hpp b/test/oracle/oracle.hpp new file mode 100644 index 0000000..de21a4b --- /dev/null +++ b/test/oracle/oracle.hpp @@ -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 diff --git a/test/oracle/pairs_demo.cpp b/test/oracle/pairs_demo.cpp new file mode 100644 index 0000000..d1ce669 --- /dev/null +++ b/test/oracle/pairs_demo.cpp @@ -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 diff --git a/test/oracle/pairs_render.cpp b/test/oracle/pairs_render.cpp new file mode 100644 index 0000000..e56179e --- /dev/null +++ b/test/oracle/pairs_render.cpp @@ -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(in_len > 0 ? in[0] : 0u) * 2.0f; + const f32 h = 300.0f + static_cast(in_len > 1 ? in[1] : 0u) * 2.0f; + const f32 inset = 40.0f + static_cast(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(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(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(out_cap / (4u * 32u)); + if (fh <= 0) return 0; + + render::Framebuffer fb; + fb.pixels = reinterpret_cast(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(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(fw) * static_cast(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 diff --git a/test/oracle/selftest_main.cpp b/test/oracle/selftest_main.cpp new file mode 100644 index 0000000..009db3a --- /dev/null +++ b/test/oracle/selftest_main.cpp @@ -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; +} diff --git a/test/test_arena.cpp b/test/test_arena.cpp new file mode 100644 index 0000000..b237bea --- /dev/null +++ b/test/test_arena.cpp @@ -0,0 +1,122 @@ +// 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; +} diff --git a/test/test_new_guard.cpp b/test/test_new_guard.cpp new file mode 100644 index 0000000..5b1e240 --- /dev/null +++ b/test/test_new_guard.cpp @@ -0,0 +1,31 @@ +// test/test_new_guard.cpp — declenche VOLONTAIREMENT le garde-fou. +// +// CE TEST DOIT ECHOUER. CMake le declare avec WILL_FAIL TRUE : ctest le +// considere reussi si et seulement si le processus se termine anormalement. +// +// C est la preuve demandee au chantier 3 : le filet de securite du pilier 2 +// fonctionne reellement, il n est pas seulement ecrit. +// +// Ce qu on observe quand on le lance a la main : +// proj3: ALLOCATION INTERDITE: operator new taille=64 +// Le projet n alloue rien apres l init. Tout passe par une arene ... +// code de sortie 71 + +#include "proj3/sys/panic.hpp" + +using namespace proj3; + +// volatile : empeche le compilateur d elider l allocation. Sans cela, un +// -O2 un peu zele supprimerait le new et le test ne prouverait rien. +volatile void* g_sink = nullptr; + +int main() { + err_write("=== garde-fou d allocation ===\n"); + err_write("Ce programme DOIT se terminer anormalement (code 71).\n"); + err_write("S il affiche la derniere ligne, le garde-fou ne marche pas.\n\n"); + + g_sink = new char[64]; + + err_write("\nECHEC : l allocation est passee, le garde-fou est inoperant.\n"); + return 0; +} diff --git a/test/test_raster_golden.cpp b/test/test_raster_golden.cpp new file mode 100644 index 0000000..9f160b2 --- /dev/null +++ b/test/test_raster_golden.cpp @@ -0,0 +1,274 @@ +// test/test_raster_golden.cpp — VALIDATION DU PORTAGE DU RASTERIZER. +// +// Compare, octet par octet, la sortie du code porte (proj3) a une reference +// produite par le code d ORIGINE de Gastinel Write (tools/write_reference_dump.cpp). +// Une divergence est un bug de portage, pas une tolerance a accorder. +// +// Ce test tourne sur la machine de dev. Ni telephone, ni affichage. +// +// NOTE SUR LA LECTURE DE FICHIER. Le rasterizer et le parser ne lisent aucun +// fichier : c est l appelant qui fournit un tampon en memoire. C est le +// decouplage demande au chantier 5 (l original appelait fopen depuis +// TtfFont::load_from_file). Ici, l appelant est ce test, sur la cible hote, +// et il utilise donc stdio. Sur la cible embarquee, l appelant utilisera +// sys::open / sys::read. Aucune des deux voies ne traverse le rasterizer. +// +// Ce binaire lie proj3_newguard : si le portage avait laisse une allocation +// dynamique quelque part, il mourrait ici avec le code 71. + +#include + +#include "proj3/font/ttf.hpp" +#include "proj3/mem/system.hpp" +#include "proj3/render/rasterizer.hpp" +#include "proj3/sys/panic.hpp" + +using namespace proj3; + +namespace { + +int g_failures = 0; +int g_lines = 0; + +// Lecture d un fichier entier dans une arene. stdio est autorise ici (cible +// hote) ; fread n alloue pas via operator new, le garde-fou reste satisfait. +u8* read_all(const char* path, mem::Arena& a, usize& out_size) { + std::FILE* f = std::fopen(path, "rb"); + if (!f) return nullptr; + std::fseek(f, 0, SEEK_END); + const long n = std::ftell(f); + std::fseek(f, 0, SEEK_SET); + if (n <= 0) { + std::fclose(f); + return nullptr; + } + u8* buf = a.alloc_array(static_cast(n) + 1); + const usize got = std::fread(buf, 1, static_cast(n), f); + std::fclose(f); + if (got != static_cast(n)) return nullptr; + buf[n] = 0; + out_size = static_cast(n); + return buf; +} + +// --- Analyse lexicale minimale du fichier golden --------------------------- +struct Cursor { + const char* p; + const char* end; +}; + +void skip_spaces(Cursor& c) { + while (c.p < c.end && (*c.p == ' ' || *c.p == '\t')) ++c.p; +} + +bool parse_u32(Cursor& c, u32& out) { + skip_spaces(c); + if (c.p >= c.end || *c.p < '0' || *c.p > '9') return false; + u32 v = 0; + while (c.p < c.end && *c.p >= '0' && *c.p <= '9') v = v * 10u + static_cast(*c.p++ - '0'); + out = v; + return true; +} + +bool parse_i32(Cursor& c, i32& out) { + skip_spaces(c); + bool neg = false; + if (c.p < c.end && *c.p == '-') { + neg = true; + ++c.p; + } + u32 v = 0; + if (!parse_u32(c, v)) return false; + out = neg ? -static_cast(v) : static_cast(v); + return true; +} + +// Les tailles sont ecrites par %g et sont toutes entieres dans le jeu de test. +// On accepte quand meme une partie fractionnaire, pour que le format ne se +// referme pas sur une hypothese. +bool parse_f32(Cursor& c, f32& out) { + skip_spaces(c); + i32 whole = 0; + if (!parse_i32(c, whole)) return false; + f32 v = static_cast(whole); + if (c.p < c.end && *c.p == '.') { + ++c.p; + f32 scale = 0.1f; + while (c.p < c.end && *c.p >= '0' && *c.p <= '9') { + v += static_cast(*c.p++ - '0') * scale; + scale *= 0.1f; + } + } + out = v; + return true; +} + +i32 hex_digit(char ch) { + if (ch >= '0' && ch <= '9') return ch - '0'; + if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10; + if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10; + return -1; +} + +void fail(const char* what, u32 cp, f32 px) { + ++g_failures; + err_write("ECHEC "); + err_write(what); + err_write(" codepoint="); + err_write_hex(cp); + err_write(" taille="); + err_write_i64(static_cast(px)); + err_write("\n"); +} + +} // namespace + +int main(int argc, char** argv) { + if (argc < 3) { + err_write("usage: proj3_test_raster \n"); + return 2; + } + + static mem::System sys; + if (!mem::system_init(sys)) { + err_write("acquisition memoire impossible\n"); + return 2; + } + + // Les deux fichiers vivent dans l arene de scanout, qui est la plus grande + // et n a aucun usage a ce stade des chantiers. C est un detournement + // assume et local a ce test. + usize ttf_size = 0, golden_size = 0; + const u8* ttf = read_all(argv[1], sys.scanout, ttf_size); + if (ttf == nullptr) { + err_write("police illisible\n"); + return 2; + } + const u8* golden = read_all(argv[2], sys.scanout, golden_size); + if (golden == nullptr) { + err_write("fichier golden illisible : lancer d abord proj3_write_reference\n"); + return 2; + } + + font::TtfFont f; + const char* err = nullptr; + if (!f.load(ttf, ttf_size, sys.atlas, err)) { + err_write("chargement TTF : "); + err_write(err); + err_write("\n"); + return 2; + } + err_write("police chargee : upem="); + err_write_i64(f.units_per_em()); + err_write(" glyphes="); + err_write_i64(f.num_glyphs()); + err_write(" entrees cmap="); + err_write_i64(f.cmap_size()); + err_write("\n\n"); + + font::GlyphBuilder builder; + builder.init(sys.atlas); + + Cursor c{reinterpret_cast(golden), + reinterpret_cast(golden) + golden_size}; + + while (c.p < c.end) { + // Une ligne a la fois. + const char* line_end = c.p; + while (line_end < c.end && *line_end != '\n') ++line_end; + Cursor line{c.p, line_end}; + c.p = (line_end < c.end) ? line_end + 1 : c.end; + + skip_spaces(line); + if (line.p >= line.end || *line.p == '#' || *line.p == '\r') continue; + + u32 cp = 0, gid_ref = 0, ok_ref = 0; + f32 px = 0.0f; + i32 w_ref = 0, h_ref = 0, bx_ref = 0, by_ref = 0, adv_ref = 0; + if (!parse_u32(line, cp) || !parse_f32(line, px) || !parse_u32(line, gid_ref) || + !parse_u32(line, ok_ref) || !parse_i32(line, w_ref) || !parse_i32(line, h_ref) || + !parse_i32(line, bx_ref) || !parse_i32(line, by_ref) || !parse_i32(line, adv_ref)) { + err_write("ECHEC ligne golden malformee\n"); + ++g_failures; + continue; + } + skip_spaces(line); + const char* hex = line.p; + usize hex_len = 0; + while (line.p < line.end && hex_digit(*line.p) >= 0) { + ++line.p; + ++hex_len; + } + ++g_lines; + + // --- Cote proj3 ----------------------------------------------------- + const u16 gid = f.glyph_index_for_codepoint(cp); + if (static_cast(gid) != gid_ref) { + fail("index de glyphe different (cmap)", cp, px); + continue; + } + font::Glyph g; + f.load_glyph(gid, builder, g); + + const usize m_atlas = sys.atlas.mark(); + const usize m_geo = sys.geometry.mark(); + render::RasterizedGlyph rg; + const bool ok = render::rasterize_glyph(g, f.units_per_em(), px, sys.atlas, + sys.geometry, rg); + + if (ok != (ok_ref != 0)) { + fail("rasterize_glyph : succes/echec different", cp, px); + } else if (!ok) { + // Glyphe vide : seule l avance a un sens, et elle doit coincider. + if (rg.advance != adv_ref) fail("avance differente (glyphe vide)", cp, px); + } else { + if (rg.coverage.width != w_ref || rg.coverage.height != h_ref) { + fail("dimensions du bitmap differentes", cp, px); + } else if (rg.bearing_x != bx_ref || rg.bearing_y != by_ref) { + fail("bearing different", cp, px); + } else if (rg.advance != adv_ref) { + fail("avance differente", cp, px); + } else if (hex_len != rg.coverage.size_bytes() * 2) { + fail("longueur de couverture differente", cp, px); + } else { + // Comparaison octet par octet. Aucun epsilon : la couverture + // est binaire, l egalite doit etre exacte. + usize bad = rg.coverage.size_bytes(); + for (usize i = 0; i < rg.coverage.size_bytes(); ++i) { + const i32 hi = hex_digit(hex[i * 2]); + const i32 lo = hex_digit(hex[i * 2 + 1]); + const u8 expect = static_cast((hi << 4) | lo); + if (rg.coverage.pixels[i] != expect) { + bad = i; + break; + } + } + if (bad != rg.coverage.size_bytes()) { + fail("pixel divergent", cp, px); + err_write(" premier octet divergent a l offset "); + err_write_i64(static_cast(bad)); + err_write(" (x="); + err_write_i64(static_cast(bad % static_cast(w_ref))); + err_write(" y="); + err_write_i64(static_cast(bad / static_cast(w_ref))); + err_write(") attendu="); + err_write_hex(static_cast((hex_digit(hex[bad * 2]) << 4) | + hex_digit(hex[bad * 2 + 1]))); + err_write(" obtenu="); + err_write_hex(rg.coverage.pixels[bad]); + err_write("\n"); + } + } + } + + sys.geometry.rewind_to(m_geo); + sys.atlas.rewind_to(m_atlas); + } + + err_write("\nlignes comparees : "); + err_write_i64(g_lines); + err_write("\nechecs : "); + err_write_i64(g_failures); + err_write("\n"); + return g_failures == 0 ? 0 : 1; +} diff --git a/test/test_syscalls.cpp b/test/test_syscalls.cpp new file mode 100644 index 0000000..3054f4d --- /dev/null +++ b/test/test_syscalls.cpp @@ -0,0 +1,263 @@ +// test/test_syscalls.cpp — harnais des wrappers d appels systeme (chantier 2). +// +// OU L EXECUTER : n importe quel Linux AArch64. Raspberry Pi sous 64 bits, +// VM ARM, conteneur, ou qemu-user. PAS BESOIN DU TELEPHONE : aucun test ne +// touche au graphique, a l entree, ni au reseau. +// +// qemu-aarch64 ./proj3_test_syscalls # emulation utilisateur +// ./proj3_test_syscalls # natif +// +// Code de sortie : 0 si tout passe, 1 sinon. Chaque ligne dit OK ou ECHEC. +// +// LE CAS D ERREUR EST LE PLUS IMPORTANT. Un wrapper qui rendrait -2 et qu on +// interpreterait comme un descripteur valide donnerait un bug tres loin d ici. +// Chaque appel a donc son cas nominal ET son cas d erreur, et le cas d erreur +// verifie a la fois is_err() ET le code errno exact. + +#include "proj3/base/mem.hpp" +#include "proj3/sys/panic.hpp" +#include "proj3/sys/syscalls.hpp" +#include "proj3/sys/uapi.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; +} + +void check_err(const sys::Result r, i32 expected_errno, const char* what) { + const bool ok = r.is_err() && r.err() == expected_errno; + err_write(ok ? "OK " : "ECHEC "); + err_write(what); + if (!ok) { + err_write(" (attendu -"); + err_write_i64(expected_errno); + err_write(", obtenu "); + err_write_i64(r.raw); + err_write(")"); + ++g_failures; + } + err_write("\n"); +} + +// Chemin garanti inexistant. On evite /tmp, qui peut etre monte en lecture +// seule ou absent sur un systeme minimal. +const char kMissing[] = "/proj3-ce-fichier-n-existe-pas-42"; +const char kSelf[] = "/proc/self/maps"; + +} // namespace + +extern "C" int proj3_main(int, char**) { + err_write("=== wrappers syscall AArch64 ===\n\n"); + + // --- Verification prealable de la convention elle-meme ----------------- + // Si ces trois assertions ne tenaient pas, tous les tests suivants + // seraient sans valeur. + { + constexpr sys::Result ok_zero{0}; + constexpr sys::Result ok_big{-4096}; + constexpr sys::Result err_min{-1}; + constexpr sys::Result err_max{-4095}; + static_assert(!ok_zero.is_err()); + static_assert(!ok_big.is_err(), "-4096 est HORS de la plage d erreur"); + static_assert(err_min.is_err() && err_min.err() == 1); + static_assert(err_max.is_err() && err_max.err() == 4095); + check(true, "plage d erreur [-4095,-1] exacte (verifiee a la compilation)"); + } + + // --- getpid : nominal seulement (il ne peut pas echouer) --------------- + { + const sys::Result r = sys::getpid(); + check(r.is_ok() && r.value() > 0, "getpid nominal"); + } + + // --- write ------------------------------------------------------------ + { + const char msg[] = ""; + const sys::Result r = sys::write(sys::FD_STDOUT, msg, 0); + check(r.is_ok() && r.value() == 0, "write nominal (0 octet)"); + } + { + const sys::Result r = sys::write(-1, "x", 1); + check_err(r, sys::EBADF, "write cas d erreur (descripteur invalide -> EBADF)"); + } + + // --- open -------------------------------------------------------------- + // LE test qui compte : un open sur un fichier absent doit remonter une + // erreur, pas un descripteur. + { + const sys::Result r = sys::open(kMissing, sys::O_RDONLY); + check_err(r, sys::ENOENT, "open cas d erreur (fichier absent -> ENOENT)"); + // Verification supplementaire, explicite : la valeur ne doit surtout + // pas etre utilisable comme descripteur. + check(r.is_err(), "open absent : is_err() vaut bien true"); + } + + i32 fd = -1; + { + const sys::Result r = sys::open(kSelf, sys::O_RDONLY); + check(r.is_ok() && r.fd() >= 0, "open nominal (/proc/self/maps)"); + if (r.is_ok()) fd = r.fd(); + } + + // --- read -------------------------------------------------------------- + { + u8 buf[64]; + mem_fill(buf, 0, sizeof(buf)); + if (fd >= 0) { + const sys::Result r = sys::read(fd, buf, sizeof(buf)); + check(r.is_ok() && r.value() > 0, "read nominal"); + } else { + check(false, "read nominal (open prealable a echoue)"); + } + const sys::Result r2 = sys::read(-1, buf, sizeof(buf)); + check_err(r2, sys::EBADF, "read cas d erreur (descripteur invalide -> EBADF)"); + } + + // --- lseek ------------------------------------------------------------- + { + if (fd >= 0) { + const sys::Result r = sys::lseek(fd, 0, sys::SEEK_SET); + check(r.is_ok() && r.value() == 0, "lseek nominal (retour au debut)"); + } else { + check(false, "lseek nominal (open prealable a echoue)"); + } + const sys::Result r2 = sys::lseek(-1, 0, sys::SEEK_SET); + check_err(r2, sys::EBADF, "lseek cas d erreur (descripteur invalide -> EBADF)"); + } + + // --- fstat ------------------------------------------------------------- + { + sys::Stat st; + mem_fill(&st, 0, sizeof(st)); + if (fd >= 0) { + const sys::Result r = sys::fstat(fd, &st); + // /proc/self/maps a une taille declaree nulle : on verifie le mode, + // pas la taille. S_IFREG = 0100000 octal. + check(r.is_ok() && (st.mode & 0170000u) == 0100000u, + "fstat nominal (mode de fichier regulier)"); + } else { + check(false, "fstat nominal (open prealable a echoue)"); + } + const sys::Result r2 = sys::fstat(-1, &st); + check_err(r2, sys::EBADF, "fstat cas d erreur (descripteur invalide -> EBADF)"); + } + + // --- ioctl ------------------------------------------------------------- + // Aucun ioctl graphique dans cette passe. On se contente de verifier que + // le wrapper transmet bien et que l erreur remonte : un ioctl inconnu sur + // un fichier regulier donne ENOTTY. + { + if (fd >= 0) { + const sys::Result r = sys::ioctl(fd, 0xDEADu); + check(r.is_err() && (r.err() == sys::ENOTTY || r.err() == sys::EINVAL), + "ioctl cas d erreur (requete inconnue -> ENOTTY/EINVAL)"); + } else { + check(false, "ioctl cas d erreur (open prealable a echoue)"); + } + const sys::Result r2 = sys::ioctl(-1, 0x1234u); + check_err(r2, sys::EBADF, "ioctl descripteur invalide -> EBADF"); + } + + // --- close ------------------------------------------------------------- + { + if (fd >= 0) { + const sys::Result r = sys::close(fd); + check(r.is_ok(), "close nominal"); + } else { + check(false, "close nominal (open prealable a echoue)"); + } + const sys::Result r2 = sys::close(-1); + check_err(r2, sys::EBADF, "close cas d erreur (descripteur invalide -> EBADF)"); + } + + // --- mmap / munmap / madvise ------------------------------------------- + // Verification explicite du 6e argument de mmap : on mappe avec un offset + // non nul sur un descripteur invalide. Si le 6e argument n arrivait pas au + // noyau, l erreur serait EINVAL au lieu de EBADF. + { + const usize len = 4096; + const sys::Result r = sys::mmap(nullptr, len, sys::PROT_READ | sys::PROT_WRITE, + sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0); + check(r.is_ok(), "mmap nominal (anonyme 4 Ko)"); + if (r.is_ok()) { + u8* p = static_cast(r.ptr()); + p[0] = 0x42; + p[len - 1] = 0x43; + check(p[0] == 0x42 && p[len - 1] == 0x43, "mmap : la memoire est ecrivable"); + + const sys::Result a = sys::madvise(p, len, sys::MADV_WILLNEED); + check(a.is_ok(), "madvise nominal (MADV_WILLNEED)"); + + const sys::Result u = sys::munmap(p, len); + check(u.is_ok(), "munmap nominal"); + } else { + check(false, "mmap : la memoire est ecrivable (mmap a echoue)"); + check(false, "madvise nominal (mmap a echoue)"); + check(false, "munmap nominal (mmap a echoue)"); + } + } + { + // Longueur nulle : EINVAL. Cas d erreur simple et sans effet de bord. + const sys::Result r = sys::mmap(nullptr, 0, sys::PROT_READ, + sys::MAP_PRIVATE | sys::MAP_ANONYMOUS, -1, 0); + check_err(r, sys::EINVAL, "mmap cas d erreur (longueur nulle -> EINVAL)"); + } + { + // 6e argument : offset non nul, descripteur invalide, mapping de + // fichier. Le noyau doit voir un fd invalide (EBADF). + const sys::Result r = sys::mmap(nullptr, 4096, sys::PROT_READ, sys::MAP_PRIVATE, -1, + 4096); + check(r.is_err(), "mmap 6e argument : l appel parvient au noyau et echoue proprement"); + } + { + const sys::Result r = sys::munmap(nullptr, 0); + check_err(r, sys::EINVAL, "munmap cas d erreur (longueur nulle -> EINVAL)"); + } + { + const sys::Result r = sys::madvise(nullptr, 0, 0xFFFF); + check(r.is_err(), "madvise cas d erreur (conseil inconnu)"); + } + + // --- clock_gettime ------------------------------------------------------ + { + sys::TimeSpec ts{0, 0}; + const sys::Result r = sys::clock_gettime(sys::CLOCK_MONOTONIC, &ts); + check(r.is_ok() && (ts.sec > 0 || ts.nsec > 0), "clock_gettime nominal (MONOTONIC)"); + + const sys::Result r2 = sys::clock_gettime(0x7FFF, &ts); + check(r2.is_err(), "clock_gettime cas d erreur (horloge inconnue)"); + } + + // --- nanosleep ---------------------------------------------------------- + { + const sys::TimeSpec req{0, 1000000}; // 1 ms + const sys::Result r = sys::nanosleep(&req, nullptr); + check(r.is_ok(), "nanosleep nominal (1 ms)"); + + const sys::TimeSpec bad{0, 2000000000}; // nsec >= 1e9 : invalide + const sys::Result r2 = sys::nanosleep(&bad, nullptr); + check_err(r2, sys::EINVAL, "nanosleep cas d erreur (nsec hors bornes -> EINVAL)"); + } + + // --- exit / exit_group --------------------------------------------------- + // Ils ne reviennent pas : on ne peut pas les tester ici sans terminer le + // processus. Ils sont testes IMPLICITEMENT et de la seule facon possible : + // ce programme se termine par exit_group via asm/start.S, et son code de + // sortie est observable par le script appelant. Si exit_group etait faux, + // ce binaire ne rendrait jamais la main proprement. + err_write("NOTE exit/exit_group : testes implicitement par la terminaison\n"); + err_write(" de ce programme (code de sortie observable a l exterieur).\n"); + + err_write("\nechecs : "); + err_write_i64(g_failures); + err_write("\n"); + return g_failures == 0 ? 0 : 1; +} diff --git a/tools/regen-golden.sh b/tools/regen-golden.sh new file mode 100644 index 0000000..b9ae597 --- /dev/null +++ b/tools/regen-golden.sh @@ -0,0 +1,27 @@ +#!/bin/sh +# tools/regen-golden.sh — regenere test/data/golden_write.txt depuis les +# sources ORIGINALES de Gastinel Write. +# +# A relancer uniquement si le rasterizer de Write change, ou si le jeu de +# glyphes de tools/write_reference_dump.cpp est etendu. +# +# NE PAS le relancer pour "faire passer" un test golden qui echoue : un echec +# signifie que le portage a diverge, et c est le portage qu il faut corriger. +# +# usage : tools/regen-golden.sh +set -eu + +if [ $# -lt 1 ]; then + echo "usage: $0 " >&2 + exit 2 +fi +WRITE_SRC="$1" +ROOT="$(cd "$(dirname "$0")/.." && pwd)" + +cmake -S "$ROOT" -B "$ROOT/build-host" -G Ninja -DPROJ3_WRITE_SRC="$WRITE_SRC" +ninja -C "$ROOT/build-host" proj3_write_reference + +"$ROOT/build-host/proj3_write_reference" "$ROOT/test/data/Inter-Regular.ttf" \ + > "$ROOT/test/data/golden_write.txt" + +echo "golden regenere : $(wc -l < "$ROOT/test/data/golden_write.txt") lignes" diff --git a/tools/write_reference_dump.cpp b/tools/write_reference_dump.cpp new file mode 100644 index 0000000..ec24715 --- /dev/null +++ b/tools/write_reference_dump.cpp @@ -0,0 +1,87 @@ +// tools/write_reference_dump.cpp — ORACLE EXTERNE DU PORTAGE. +// +// Ce programme compile les sources ORIGINALES de Gastinel Write +// (src/font/ttf.cpp et src/render/rasterizer.cpp, qui ne dependent d aucune +// API Windows) et vide leurs sorties dans un format texte. +// +// C est ce qui rend le portage verifiable au lieu de simplement plausible : +// le test test_raster_golden.cpp compare octet par octet la sortie du code +// porte a celle produite ici par le code d origine. Si les deux divergent, +// c est un bug de portage et il doit etre trouve maintenant. +// +// Construction (cible hote uniquement) : +// cmake -B build-host -G Ninja -DPROJ3_WRITE_SRC="<...>/Gastinel Write/src" +// ninja -C build-host proj3_write_reference +// ./build-host/proj3_write_reference test/data/Inter-Regular.ttf > test/data/golden_write.txt +// +// FORMAT (v1), une ligne par (codepoint, taille) : +// +// `ok` vaut 1 si rasterize_glyph a rendu true. Quand il vaut 0, les champs +// suivants valent 0 et le hex est vide. + +#include +#include +#include +#include + +#include "font/ttf.h" +#include "render/rasterizer.h" + +namespace { + +// Jeu de glyphes. Choisi pour couvrir : +// - des glyphes simples (A, o, 0) ; +// - des composites, qui exercent la recursion et la matrice 2x2 (e aigu, +// a grave, c cedille, u trema) ; +// - de la ponctuation fine, ou l arrondi au pixel se voit ; +// - l espace, glyphe vide dont seules les metriques comptent. +const unsigned kCodepoints[] = { + 0x20, 0x21, 0x2C, 0x2E, 0x30, 0x31, 0x38, 0x41, 0x42, 0x47, 0x4F, 0x57, + 0x61, 0x62, 0x67, 0x6D, 0x6F, 0x73, 0x77, 0x7A, 0x23, 0x25, 0x26, 0x3F, + 0xE9, 0xE0, 0xE7, 0xFC, 0xD8, 0x40, +}; + +// Tailles en pixels par em. 12 et 16 sont les corps de texte ou l arrondi est +// le plus sensible ; 24 et 32 exercent des courbes plus longues, donc des +// subdivisions plus nombreuses. +const float kSizes[] = {12.0f, 16.0f, 24.0f, 32.0f}; + +} // namespace + +int main(int argc, char** argv) { + if (argc < 2) { + std::fprintf(stderr, "usage: %s \n", argv[0]); + return 2; + } + gw::font::TtfFont font; + std::string err; + if (!font.load_from_file(argv[1], err)) { + std::fprintf(stderr, "chargement impossible : %s\n", err.c_str()); + return 2; + } + + std::printf("# proj3 golden raster dump v1 (source : Gastinel Write)\n"); + std::printf("# upem %u\n", static_cast(font.units_per_em())); + + for (unsigned cp : kCodepoints) { + const unsigned gid = font.glyph_index_for_codepoint(cp); + gw::font::Glyph g; + const bool loaded = font.load_glyph(static_cast(gid), g); + for (float px : kSizes) { + gw::render::RasterizedGlyph rg; + const bool ok = loaded && gw::render::rasterize_glyph(g, font.units_per_em(), px, rg); + std::printf("%u %g %u %d", cp, static_cast(px), gid, ok ? 1 : 0); + if (ok) { + std::printf(" %d %d %d %d %d ", rg.coverage.width, rg.coverage.height, + rg.bearing_x, rg.bearing_y, rg.advance); + for (unsigned char v : rg.coverage.pixels) std::printf("%02x", v); + } else { + // Meme quand la rasterization echoue (glyphe vide), l avance + // reste significative : elle positionne le caractere suivant. + std::printf(" 0 0 0 0 %d ", rg.advance); + } + std::printf("\n"); + } + } + return 0; +}