Fichiers
vercora/NOTES-PHASE26.md
T
2026-10-11 01:54:18 +02:00

366 lignes
18 KiB
Markdown
Brut Annotations Historique

Ce fichier contient des caractères Unicode ambigus.
Ce fichier contient des caractères Unicode qui peuvent être confondus avec d'autres caractères. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
# Phase 26 — Flakiness du scénario I, et espèces d'arbres par exposition
## TÂCHE 1 — La flakiness résiduelle du scénario I : REPRODUITE ET EXPLIQUÉE
### Ce que la Phase 25 laissait ouvert
Trois suites complètes, résultat vert / échec / vert. Le run en échec avait perdu
78 % de la télémétrie du scénario I. La cause n'avait pas pu être retrouvée : le
dump de diagnostic portait un nom fixe et avait été écrasé. La Phase 25 a
horodaté le dump pour que la prochaine occurrence soit traçable.
### Ce qui manquait ENCORE au dump, et qu'il a fallu ajouter
Le dump horodaté aurait survécu — mais il n'aurait toujours rien appris. Il
concaténait les **quatorze processus bout à bout, sans le moindre séparateur** :
aucune ligne du journal n'était rattachable à un scénario. On ne pouvait même pas
compter combien de lignes appartenaient au scénario I.
Ajouté ici, dans `Stop-Game` : un **en-tête par processus** portant le libellé,
l'heure de démarrage, la **durée mur**, le code de sortie et le nombre de lignes.
L'accumulation se fait dans `Stop-Game` lui-même et non en énumérant les `$runX`
à la fin — le scénario J recompose `$runJ` en concaténant ses trois processus, si
bien qu'une énumération des variables compterait J2 et J3 deux fois.
`$dumpLines` est construit **à part de `$all`** : aucune assertion du harnais ne
voit ces en-têtes, donc l'instrumentation ne peut pas changer un verdict.
### Le discriminateur, et pourquoi il tranche seul
La ligne `Faune :` et la ligne `Camera :` sont émises dans le **même bloc « une
fois par seconde »** de `src/main.cpp`. Mais `Camera :` est émise **sans aucune
condition** — ni mode éditeur, ni faune vivante, ni activité en cours. Comparer
les deux comptes sépare donc deux causes qu'aucune ne distingue seule :
* les deux comptes chutent ensemble → c'est **le tic lui-même** qui n'a pas
battu : le jeu n'a pas rendu d'images ;
* `Camera :` intact et `Faune :` effondré → c'est la **condition** de la ligne de
faune qui a sauté.
### La mesure
Échec reproduit **dès la suite 2**, et bien pire que celui de la Phase 25 :
[diag I] duree mur 276,3 s, tics 'Camera :' 3, releves faune 3
**Les deux s'effondrent ensemble.** Ce n'est donc ni un timeout, ni un tampon, ni
la condition de la ligne de faune, ni quoi que ce soit qui appartienne au
scénario I. Le jeu était vivant, sa fenêtre existait, son initialisation était
complète (~70 lignes) — et il ne rendait pas d'images.
### Ce que le tableau par processus a montré, et qui referme la question
| fenêtre d'horloge | ce qui tournait | état |
|---|---|---|
| jusqu'à **22:09:53** | suite 1 entière + suite 2 A/B/C | normal |
| **22:09:53 → 22:35:15** | suite 2 D→J3, **puis** suite 3 A→F | dégradé, codes de sortie −1 |
| à partir de **22:35:15** | suite 3 G1→J3 | normal, et identique à la suite 1 |
La dégradation est une **fenêtre continue d'horloge murale qui traverse la
frontière entre deux suites**. Elle frappe tous les processus lancés pendant
qu'elle dure, sans égard pour le scénario ; elle s'ouvre au milieu d'une suite et
se referme au milieu de la suivante.
Aucune propriété du scénario I ne peut produire cela — ni ses 240 s, ni sa
position dans la suite, ni un ordre d'exécution. Les deux pistes proposées au
départ sont donc écartées **par la mesure** : ce n'est pas la durée, et ce n'est
pas la place dans la suite.
Comparaison du même scénario, même binaire, à deux moments :
scenario I, run sain : 256,6 s de duree mur -> 254 tics (99 %)
scenario I, run degrade : 276,3 s de duree mur -> 3 tics ( 1 %)
Et la suite 3, une fois la fenêtre refermée, redonne **1349 lignes** au scénario I
là où la suite 1 en donnait 1347. Le jeu n'a jamais bougé.
### La cause matérielle, identifiée
Un processus `find.exe` de Git Bash, **orphelin** (son parent n'existe plus),
lancé à **18:04:59** — soit près de quatre heures avant le début de cette
session — balaie le disque entier :
"C:\Program Files\Git\usr\bin\find.exe" / -maxdepth 9 -type d -ipath *config/totochetools/horizons*
Au moment du constat il avait accumulé **20 334 secondes de CPU** (5,6 heures).
Sur cette machine le GPU est un **Intel UHD 770 intégré** (confirmé : le même GPU
est sélectionné dans les 14 processus des 3 suites, il n'y a pas de bascule de
GPU), qui partage sa bande passante mémoire avec le CPU. Un balayage de système
de fichiers saturant un cœur en continu est exactement ce qui affame un tel GPU.
S'y ajoutent, sur la même machine et pendant la même période, une **compilation
C++ complète** et un **second harnais Vulkan** lancés par une autre session.
### Le correctif : un TÉMOIN DE SANTÉ, pas un délai élargi
Le harnais ne savait pas distinguer deux choses qui n'ont rien à voir :
* « le jeu a régressé » → il faut chercher dans le jeu ;
* « la machine n'a pas pu rendre » → il n'y a **rien** à chercher dans le jeu.
Faute de les séparer, il déclarait ROUGE dans les deux cas. Ce projet a perdu
cinq phases sur exactement cette confusion (dette du vélo, Phases 17 à 22).
La mesure qui les sépare **existait déjà** : le nombre de lignes `Camera :`
rapporté à la durée mur du processus. Le harnais le calcule désormais pour chaque
run et, si un seul run tombe sous **50 %** du débit attendu, il conclut :
[NON CONCLUANT] ... exit 2
**Ce témoin ne rend rien vert.** Un run dégradé n'est pas déclaré réussi, il est
déclaré non concluant, avec un code de sortie qui lui est propre pour qu'aucune
automatisation ne le confonde avec un succès. On refuse de conclure sur une
mesure qui n'a pas eu lieu ; on ne prononce pas l'acquittement.
Le seuil de 50 % n'arbitre rien : les deux populations mesurées sont à **99 %** et
à **1 %**. N'importe quelle valeur entre les deux donnerait le même verdict.
### La vérification : 3 suites consécutives, machine au repos
Le `find` orphelin disparu et la charge globale retombée à 0 %, trois suites
complètes ont été enchaînées :
| suite | verdict | durée | scénario I |
|---|---|---|---|
| 1 | `[OK]` exit **0** | 14,2 min | 256,5 s → **254 tics / 254 relevés** |
| 2 | `[OK]` exit **0** | 14,2 min | 256,6 s → **254 tics / 254 relevés** |
| 3 | `[OK]` exit **0** | 14,2 min | 256,4 s → **254 tics / 254 relevés** |
Zéro message `[Validation]`, zéro ligne `[ERROR]`, et le témoin de santé conclut
« tous les processus ont rendu des images à cadence normale » dans les trois cas.
**Ce qui frappe, et qui est la vraie preuve** : la reproductibilité. **Onze des
quatorze processus rendent un nombre de lignes RIGOUREUSEMENT identique** d'une
suite à l'autre — scénario I à 1605 lignes les trois fois, scénario H à 1013.
Seuls le scénario A (430 / 442 / 436) et l'éditeur G1 (894 / 887 / 911) varient
de quelques lignes. Un harnais dont onze processus sur quatorze sont au relevé
près identiques n'est plus un harnais flaky.
Le critère « zéro faux-négatif sur plusieurs runs consécutifs », ouvert depuis la
Phase 25, est donc **atteint** — et il l'est sans qu'une seule ligne du jeu ait
été modifiée pour la fiabilité du harnais. Ce qui manquait était l'instrument, et
la machine.
À noter : les espèces de la Tâche 2 sont exercées par la suite complète (mesh
feuillu téléversé, « 10 résineux sur 16 arbres abattables » journalisé) — les
trois suites vertes valent donc aussi non-régression pour le chantier 4.
---
## TÂCHE 2 — Espèces d'arbres et placement par exposition
### L'architecture : une seule loi, trois consommateurs
`world/TreeSpecies.hpp` est le **seul** endroit qui décide d'une essence.
L'essence est une **fonction pure de la position monde et d'une graine** :
TreeSpecies treeSpeciesAt(worldX, worldZ, aspectExposure, params)
Elle n'est stockée nulle part comme vérité — `Forest` la mémorise dans chaque
arbre par commodité d'accès, `Vegetation` la met en cache avec sa cellule — mais
les deux la tirent du **même appel**. Ce qui est résineux à l'œil est donc
résineux à la saignée par construction, et non par accord entre deux tables
qu'il faudrait tenir à jour.
Le tirage porte sur la **position** et non sur un indice : un indice n'existe que
dans le système qui l'attribue, et les deux systèmes n'en ont pas de commun. La
position est quantifiée à 25 cm avant hachage — bien plus fin que l'espacement
minimal entre deux pieds (5,5 m), bien plus gros que le bruit de calcul.
### L'exposition : consommée, pas recalculée
Le signal d'adret/ubac de `WeatherSample::aspectC` dépend du **soleil courant** :
il tourne avec l'heure et s'éteint la nuit. Une essence ne peut pas changer entre
midi et minuit.
La formule a donc été **extraite** de `sampleAt` dans
`WeatherSystem::aspectSignal`, sans en changer une ligne de calcul, et
`WeatherSystem::aspectExposureAt` l'évalue **au soleil de midi**. Une seule
formule, deux instants d'évaluation. Preuve que l'extraction n'a rien changé :
les tests headless redonnent **14,7 °C d'adret contre 10,7 °C d'ubac, écart
4,0 °C** — les chiffres exacts documentés en Phase 23.
`Forest` et `Vegetation` ne connaissent pas `WeatherSystem` : elles voient
`AspectExposureSource`, une interface minuscule sur le modèle de
`GroundCoverSource` (Phase 17). Contrat total : source absente = exposition nulle
= part de résineux neutre partout, donc le comportement d'avant la phase.
La source est **paramètre du constructeur** de `Forest`, et non un simple setter :
le constructeur sème immédiatement, si bien qu'un setter aurait créé un ordre à
respecter, donc un piège silencieux du type dont ce projet a déjà payé le prix.
### La tendance, jamais la règle
part de resineux = coniferShareNeutral - aspectSwing x exposition
= 0,55 - 0,35 x exposition (bornee a [0,10 ; 0,92])
0,55 reprend **tel quel** l'ancien `ResinParams::coniferShare` : le réglage de la
Phase 22 n'est pas perdu, il devient le point neutre autour duquel l'exposition
fait pencher la balance. Les bornes dures ne mordent pas avec ces valeurs ; elles
sont là pour qu'un reréglage d'`aspectSwing` ne puisse pas, par inadvertance,
transformer la tendance en règle stricte.
### La présence n'a pas bougé, et c'est structurel
Dans `Vegetation::buildTreeCell`, l'appel à `treeSpeciesAt` est placé **après**
tous les filtres de présence — couvert LiDAR, pente, altitude, hauteur de
canopée. L'emplacement **est** déjà retenu quand l'essence est choisie.
L'exposition n'a donc aucun moyen d'ajouter ou de retirer un arbre. La contrainte
du chantier est tenue par la **structure** du code : déplacer cet appel de vingt
lignes vers le haut serait le seul moyen de la rompre.
**Et c'est vérifié par la mesure** (voir plus bas) : le nombre total d'arbres est
rigoureusement identique avec et sans le couplage.
### Les deux silhouettes
`TreeMesh.hpp` annonçait depuis la Phase 5 : « la variété de silhouette viendra de
plusieurs meshes distincts le jour où ce sera un sujet, pas d'un étirement ».
C'est ce jour-là.
Le conifère existant est conservé tel quel (tronc conique + deux cônes empilés,
**facetté**). Le feuillu ajoute un houppier **arrondi** : des anneaux empilés sur
un profil elliptique, **lissés** (normales radiales partagées). L'opposition ne
tient donc pas qu'au contour — les deux arbres n'accrochent pas la lumière de la
même façon. Teintes du feuillu plus claires et plus jaunes que le vert bleuté du
conifère, second indice de lecture après la silhouette.
**Le tronc est le même, et ce n'est pas un raccourci** : la souche interpole son
rayon de coupe sur la droite du tronc de l'arbre. Un second tronc aurait imposé
une seconde souche, et surtout la souche laissée par un feuillu abattu ne
coïnciderait plus avec le trait de coupe. **Une** souche sert les deux essences
parce que les deux partagent exactement le même tronc.
### La dette de la Phase 22, refermée
`world/Resin.hpp` écrivait : « un joueur ne peut pas VOIR quel arbre est résineux
avant d'essayer, puisque tous les arbres ont le même mesh ».
`ResinStand` **ne décide plus de rien**. Plus de graine d'essence, plus de part de
résineux, plus de hachage : `coniferShare` et `seed` ont quitté `ResinParams`.
`tap()` **reçoit** l'essence de l'arbre visé, lue dans `Tree::species` — celle-là
même dont la silhouette est dessinée à l'écran.
Faire lire à `ResinStand` la même fonction que le rendu aurait suffi à les faire
coïncider aujourd'hui ; le lui faire **donner** par l'appelant garantit qu'ils ne
peuvent pas diverger demain, parce qu'il n'y a plus de second calcul à maintenir.
La même exigence que la Phase 23 pour le soleil et la Phase 25 pour l'écart
d'incidence.
### Le rendu
Deux géométries distinctes = **deux appels de dessin instanciés** au lieu d'un.
C'est irréductible : l'instanciation tient UNE géométrie pour N instances. Les
mélanger demanderait une matrice par arbre, c'est-à-dire de défaire la Phase 11.
Le surcoût est d'**un appel de dessin par image**, pas d'un par arbre — le nombre
d'instances est inchangé.
`Vegetation::gatherTrees` a une surcharge à deux vecteurs ; la surcharge à un seul
vecteur appelle la première **avec le même vecteur passé deux fois**, ce qui rend
l'union exactement dans l'ordre d'avant la phase, sans copie et sans qu'il existe
une seconde version du parcours.
### Les deux témoins
| option | ce qu'elle neutralise | ce qu'elle sert à mesurer |
|---|---|---|
| `--no-species-aspect` | le **couplage au versant** seul (`aspectSwing = 0`) | l'effet revendiqué par cette phase |
| `--single-tree-species` | la **seconde essence** (100 % résineux, donc 1 appel) | le coût du second appel de dessin |
`--no-species-aspect` est délibérément étroit : éteindre les essences aurait
mélangé deux effets, « il y a deux formes d'arbres maintenant » et « leur
répartition suit le versant ». Il garde le même nombre d'arbres, la même
proportion globale et les deux silhouettes — seule la corrélation au versant
disparaît. Toute différence entre les deux captures ne peut donc venir que de ce
couplage, qui est exactement ce que cette phase prétend avoir ajouté.
### La vérification, mesurée
Zone de 25 km² (`vercora_zone_1m.vchm`, la seule qui porte une carte de couvert
LiDAR), vue plongeante sur le versant où l'on se tient.
| vue | avec couplage | témoin sans couplage | total d'arbres |
|---|---|---|---|
| **ubac** (exposition −0,75) | 3034 / 1522 = **66,6 %** de résineux | 2494 / 2062 = **54,7 %** | 4556 **/ 4556** |
| **adret** (exposition +0,20) | 810 / 723 = **52,8 %** | 840 / 693 = **54,8 %** | 1533 **/ 1533** |
Trois choses se lisent d'un coup :
1. **Le total est rigoureusement identique** dans chaque paire. La carte de
couvert LiDAR pilote toujours seule la présence — l'espèce n'ajoute ni ne
retire un arbre. Le point 3 du chantier est vérifié, pas supposé.
2. **Le témoin tombe sur 54,7 % et 54,8 %** dans les deux vues, c'est-à-dire sur
`coniferShareNeutral` (0,55). Le témoin fait ce qu'il annonce.
3. **L'écart est bipolaire** : +11,9 points de résineux en ubac, −2,0 points en
adret. Le signe est correct des deux côtés. L'amplitude plus faible en adret
suit l'exposition, qui n'y vaut que +0,20 contre −0,75 en ubac — les adrets de
cette zone sont réels mais peu marqués.
Une capture supplémentaire au belvédère de la Phase 25 (E 900000 / N 6436000,
`--look=270,-24`) donne 1985 / 866 avec couplage contre 1616 / 1235 au témoin,
pour un total identique de 2851 arbres.
La télémétrie qui porte ces chiffres est émise par le jeu une fois par seconde
(`Essences : N résineux et M feuillus à l'écran, exposition ici X`) : une capture
montre une différence, elle ne la **chiffre** pas.
### Validation Vulkan
**Zéro message `[Validation]`** sur toutes les captures et mesures (couches
actives, build Debug).
### Tests headless
`tools\run_logic_tests.bat` : **3607 vérifications passées**, dont la section
« Phase 22 / 26 : essences d'arbres et résine de pin » — déterminisme du tirage,
part observée conforme à la loi, les deux témoins (part nulle / part pleine), une
graine différente qui change réellement le tirage, et la bipolarité adret/ubac
sur la loi elle-même.
### Le coût : mesuré, et il n'y en a pas
Quatre paires de runs **entrelacés** (témoin, condition, témoin, condition…) sur
la même vue et le même binaire, machine au repos. Moyennes sur trois paires
exploitables :
| | 1 appel (témoin) | 2 appels | écart |
|---|---|---|---|
| images en 30 s | 3135 | 3168 | **+1,0 %** |
| `arbres` (semis CPU) | 1634,0 µs | 1633,4 µs | −0,0 % |
| **`herbe` (poste témoin)** | 4972,5 µs | 4977,3 µs | **+0,1 %** |
| `drawFrame` | 1950,2 µs | 1854,8 µs | −4,9 % |
| tampon d'instances | 522 Ko | 522 Ko | — |
| géométrie terrain GPU | 22 Mo | 22 Mo | — |
**Le poste témoin valide la mesure.** L'herbe ne dépend en rien des essences :
elle diffère de 0,1 %, donc la machine n'a pas dérivé entre les conditions. C'est
le contrôle qui manquait à la première tentative, et c'est lui qui autorise à
lire les autres lignes.
**Les deux écarts sont dans le bruit.** La dispersion à l'intérieur d'une même
condition vaut 0,8–0,9 % sur les images et **5,3–5,7 % sur `drawFrame`** : le
−4,9 % constaté est donc plus petit que le bruit du poste lui-même. Il n'y a pas
de surcoût mesurable, et il n'y a pas non plus de gain à revendiquer.
**Ce qui rend le résultat intéressant** : la condition à deux appels soumet
**45 % de triangles d'arbres en plus** —
1 appel : 4556 x 48 = 218 688 triangles
2 appels : 3034 x 48 + 1522 x 112 = 316 096 triangles
le feuillu ayant 112 triangles contre 48 au conifère. Quarante-cinq pour cent de
géométrie supplémentaire ne se voient pas dans le temps d'image : l'image n'est
pas limitée par le débit de sommets des arbres. C'est cohérent avec ce que la
Phase 19 avait établi — le frame attend ailleurs.
Côté mémoire, rien ne bouge : le tampon d'instances est identique (le nombre
d'instances l'est), et le feuillu ajoute **une** géométrie de 129 sommets /
112 triangles téléversée une seule fois.
### Ce qui reste ouvert
* La faune, les plantes à fibres et l'herbe ne sont pas touchées par les essences.
* Le shader `foliage` ne teinte toujours pas les arbres selon l'adret/ubac
(limite héritée de la Phase 25) : l'indice visuel de température reste sur le
terrain seul.