22 KiB
NOTES-PHASE19.md — Le profil de la Phase 18 était un profil de Debug
Session du 2026-08-26, à la suite de la Phase 18. Deux tâches étaient au programme :
- rendre
Renderer::addMeshthread-safe pour paralléliser la construction de mesh de tuile — la piste que la Phase 18 avait désignée comme le gain suivant (83 % du coût restant) ; - profiler les autres postes du frame (terrain, végétation, faune) pour trouver des gains sûrs.
Le résultat principal de la phase n'est aucun des deux, et il les annule tous les deux : la mesure qui fondait la Tâche 1 avait été relevée en Debug, et elle ne tient pas en Release. En Release, le maillage d'une tuile n'est plus le poste dominant, et le frame entier n'est pas limité par le CPU.
C'est la leçon de la Phase 18 (« un commentaire n'est pas une mesure ») appliquée un cran plus haut : un profil de Debug n'est pas un profil de Release.
Configurations et matériel : Intel UHD 770, 20 cœurs logiques, 1280x720,
caméra verrouillée (--lock-input), cadrage fixé par --start / --look
(sans --look, tout diff d'image est un artefact — cf. MEMORY.md). Sauf mention
explicite de « Release », les mesures sont en Debug avec couches de
validation, la seule configuration où le projet valide. Zéro message
[Validation] sur la totalité des mesures de ce document.
1. TÂCHE 1 — la parallélisation
1.1 Ce qui empêche réellement Renderer::addMesh d'être appelé depuis plusieurs threads
La question posée était précise, la réponse l'est aussi. addMesh touche
quatre ensembles d'état partagé, de dangerosité très inégale :
| # | État | Nature du problème |
|---|---|---|
| 1 | meshes_, freeMeshSlots_, liveMeshCount_ |
meshes_.push_back peut réallouer le vecteur pendant que recordCommandBuffer l'indexe depuis le thread de rendu. Course franche, sur un pointeur. |
| 2 | pendingCopies_, stagingBytesInFlight_ |
enqueueCopy fait push_back + += sans verrou ; vidés à chaque recordCommandBuffer. |
| 3 | commandPool_ |
flushCopiesNow y alloue un command buffer. Un VkCommandPool et tous ses command buffers exigent une synchronisation externe : allouer dedans pendant que le thread de rendu réinitialise et enregistre le sien est une violation directe de la spécification. |
| 4 | graphicsQueue_ |
flushCopiesNow fait vkQueueSubmit + vkQueueWaitIdle. Un VkQueue exige lui aussi une synchronisation externe ; en concurrence avec le vkQueueSubmit de drawFrame, c'est une corruption de driver, pas une erreur de validation. |
Les points 1 et 2 se règlent avec un mutex, moyennant un coût sur le chemin de
rendu (le point 1 impose de verrouiller aussi la lecture de meshes_ à
chaque draw, ou de figer la capacité du vecteur).
Ce sont les points 3 et 4 qui condamnent l'exercice, et pour une raison qui
n'est pas la difficulté : flushCopiesNow n'est atteint que lorsque le staging
en vol dépasse 128 Mo (kMaxPendingStagingBytes). Une tuile pèse ~385 Ko et
le budget est de 64 tuiles par frame, soit ~25 Mo : ce chemin ne se déclenche
jamais pendant le streaming. Il ne se déclenche que sur --no-lod, qui
téléverse la zone entière en un bloc — avant la première frame, donc sans
concurrence.
Autrement dit : la partie dangereuse du code serait exactement celle qu'aucun
test de cette session n'aurait pu exercer. Un verrou oublié là ne se
manifesterait ni dans le harnais, ni sous VK_LAYER_VALIDATE_SYNC, ni dans
aucune des mesures ci-dessous — mais un jour, chez l'utilisateur, sur une scène
plus grosse. C'est la définition même du bug de concurrence indétectable que la
consigne demandait d'éviter.
Renderer::addMesh n'a donc pas été modifié. Aucun appel Vulkan ne change de
thread dans cette phase.
1.2 Ce qui a été fait à la place, et pourquoi c'était le bon découpage
La Phase 18 avait déjà noté que terrainNodeMeshData est pure. Vérifié
ligne à ligne : elle ne lit que Heightmap::at/spacing/worldCoord et
TerrainQuadtree::node — tous const, sur des données immuables pour la durée
de la session — et écrit dans un MeshData qui lui appartient. Aucun static,
aucun mutable, aucun cache interne.
Le travail se découpe donc sans toucher au Renderer :
TerrainStreamer::meshBatchmaille tout le lot de la frame, en parallèle. Aucun appel Vulkan. Chaque thread écrit dans des éléments disjoints de vecteurs déjà dimensionnés : ni verrou, ni file, ni compteur partagé — donc aucun état sur lequel une course serait possible ;TerrainStreamer::uploadNodepose la topologie et appelleaddMesh, sur le thread de rendu, en séquence, dans le même ordre qu'avant.
Trois précautions, chacune pour une raison précise :
- une exception ne traverse jamais la frontière d'un
std::thread(elle appelleraitstd::terminate) : elle est capturée et rendue comme une donnée dansbatchErrors_[k]; - rien n'est journalisé depuis un thread : les fonctions de journalisation ne sont pas prévues pour ça. C'est l'appelant qui journalise, après jonction ;
- le chronomètre par tuile dépose sa durée dans un élément propre puis est sommé après jonction. Une course sur un compteur de mesure serait la pire de toutes : elle fausserait le chiffre censé prouver que le changement est bon.
Découpage statique en tranches contiguës, et non file de travail : une tuile coûte toujours la même chose (65x65 sommets quel que soit son niveau), donc l'équilibrage est naturel — et une file demanderait un verrou.
1.3 En Debug, le gain est réel
Survol scripté --flythrough=900 --no-grass, 45 s, même binaire, seule
l'option --tile-threads change (témoin de mesure, au même titre que
--no-tile-cache) :
--tile-threads=1 (témoin) |
4 threads | écart | |
|---|---|---|---|
| Travail géométrie / tuile | 1278 / 1294 µs | 1542 / 1457 µs | +16 % |
| Temps de MUR du maillage | 7255 / 7341 ms | 3620 / 3322 ms | −52 % |
| Facteur de parallélisme | 1,00 | 2,42 / 2,49 | — |
| Images en 45 s | 11 046 / 11 253 | 13 320 / 12 081 | +14 % |
| Tuiles non couvertes | 0 | 0 | — |
Deux chiffres sont publiés, et il le faut : le travail par tuile ne doit pas baisser — c'est la même fonction qui fait le même calcul — et il monte même de 16 %, parce que quatre threads se disputent la bande passante mémoire en parcourant une heightmap de 5001x5001. Ce qui doit baisser, c'est le temps que le thread de rendu passe bloqué dessus. Publier un seul des deux laisserait croire soit qu'il n'y a pas de gain, soit que le travail a diminué.
1.4 En Release, le gain disparaît — et c'est le résultat de la phase
Même survol, même méthode, build Release :
--tile-threads=1 (témoin) |
4 threads | |
|---|---|---|
| Travail géométrie / tuile | 141 / 139 µs | 154 / 146 µs |
| Temps de MUR du maillage | 819 / 811 ms | 1227 / 870 ms |
| Facteur de parallélisme | 1,00 | 0,73 / 0,97 |
| Images en 45 s | 32 206 / 32 327 | 29 776 / 32 104 |
Le facteur est inférieur à 1 : paralléliser coûte plus que ça ne rapporte. La création des threads (~3 900 sur le survol, en rafales de 3) dépasse le travail qu'elle répartit, parce qu'une tuile Release ne dure que 140 µs.
Une variante a été essayée avant de conclure — ne paralléliser qu'à partir de 16 tuiles par lot, pour ne viser que les grosses rafales. Résultat : 3 lots parallélisés en 45 s, facteur 1,01, aucun effet mesurable. L'option devient inerte, elle ne devient pas gagnante.
1.5 Pourquoi les deux mesures divergent : le coût d'une tuile, Debug vs Release
| Poste d'une tuile | Debug | Release |
|---|---|---|
| Géométrie | 1 344 µs (79 %) | 140 µs (33 %) |
| Indices | 16 µs (1 %) | 15 µs (4 %) |
| Téléversement GPU | 250 µs (15 %) | 262 µs (63 %) |
La géométrie est 9,6 fois moins chère une fois optimisée ; le téléversement, lui, ne bouge pas (c'est du memcpy et du pilote, pas du code compilé par nous). Le poste dominant d'une tuile en Release n'est donc pas la géométrie, c'est le téléversement — celui-là même que la Phase 12 avait traité et que la Phase 18 avait rangé au rang de résidu à 11 %.
La Phase 18 n'a rien mesuré de faux : ses chiffres sont exacts, en Debug. Elle en a tiré une priorité qui ne vaut que là. Et comme toutes les mesures du projet sont en Debug (c'est la seule configuration avec les couches de validation), rien ne pouvait le signaler.
1.6 Décision : défaut séquentiel, chemin parallèle conservé
Params::meshThreads vaut 1 par défaut — le réglage que la mesure désigne
en Release. Le chemin parallèle reste disponible par --tile-threads=N, testé
et documenté, pour trois raisons :
- il est un gain net de 2,4x et +14 % d'images en Debug, c'est-à-dire dans la configuration où tournent toutes les campagnes de mesure et de validation du projet — ça a une valeur d'outillage réelle ;
- il redeviendra intéressant en Release le jour où une tuile coûtera plus cher (format de sommet plus lourd, pas LiDAR plus fin) ;
- il sert de témoin : sans lui, l'écart Debug/Release ci-dessus ne serait pas reproductible sur le même binaire.
Un troisième argument, mesuré incidemment, va dans le même sens. Sur la vue de
référence en Debug, --tile-threads=4 donne une médiane identique (312 contre
311 FPS) mais un minimum de 89 FPS contre 126 : les créations de threads
introduisent des à-coups que la médiane cache. Le défaut séquentiel est aussi le
plus régulier.
1.7 Un coût mémoire introduit puis retiré
Première version : tout passait par le lot, donc jusqu'à 53 MeshData
simultanés (~287 Ko chacun, ~15 Mo). Mesuré : pic mémoire du processus
+5,6 Mo sur la vue de référence, 338,3 Mo contre 332,7 en Phase 18.
Le chemin séquentiel (le défaut) maille et téléverse donc une tuile à la
fois, sans jamais garder plus d'un MeshData en vie, et le lot est relâché
(shrink_to_fit) à la fin de la frame sur le chemin parallèle. Pic revenu à
331,7 Mo, soit 1 Mo sous la Phase 18.
C'est le genre de régression qu'on n'aurait pas vue en ne regardant que le FPS.
1.8 Comment la correction a été vérifiée
La comparaison d'images ne peut pas trancher ici, et c'est une conclusion en soi. Deux captures du jeu diffèrent déjà entre deux exécutions identiques : l'herbe et la faune s'animent avec le temps écoulé, et le temps écoulé dépend du débit d'images — que la phase change justement. Mesuré :
| Comparaison | Octets différents |
|---|---|
| Témoin : parallèle vs parallèle, mêmes options | 0,65 % / 4,40 % |
| Témoin : séquentiel vs séquentiel, sans faune | 1,54 % |
| Séquentiel vs parallèle | 0,16 % / 6,67 % |
Le plancher de bruit est du même ordre que le signal cherché. Sur la vue de référence, l'écart séquentiel/parallèle (0,16 %) est même plus petit que l'écart entre deux runs parallèles (0,65 %). Ce test ne prouve rien — ni dans un sens ni dans l'autre.
Le contrôle qui tranche est headless et déterministe (nouveau dans
tests\logic_tests.cpp) : 40 tuiles de niveaux mélangés sont maillées en
séquence puis sur 4 threads, et les sommets sont comparés par memcmp, pas à
une tolérance près — une course ne produirait pas un petit écart numérique, elle
produirait un sommet pris à la mauvaise tuile. Le test comprend son propre
témoin (vérifier que les tuiles comparées sont bien distinctes entre elles, sans
quoi la comparaison passerait sans rien prouver) et 12 passages
supplémentaires, parce qu'une course se manifeste rarement et qu'un passage
unique ne dit presque rien.
1.9 Validation de synchronisation, avec son contrôle négatif
VK_LAYER_VALIDATE_SYNC=1 sur le survol, chemin parallèle et chemin
séquentiel : 0 message.
Un journal propre ne prouve rien tant qu'on n'a pas montré que l'outil regarde au
bon endroit (MEMORY.md, leçon de la Phase 12). Contrôle négatif : la barrière
TRANSFER_WRITE -> VERTEX_ATTRIBUTE_READ | INDEX_READ de
Renderer::recordPendingCopies a été retirée, le projet rebuildé, et la couche a
immédiatement crié :
vkCmdDrawIndexed(): READ_AFTER_WRITE hazard detected. vkCmdDrawIndexed reads
index VkBuffer 0xaf00000000af, which was previously written by vkCmdCopyBuffer.
10 messages, plafond de déduplication atteint. La barrière a été remise et le journal est redevenu vide. L'outil regarde bien le chemin de téléversement des tuiles.
2. TÂCHE 2 — où passe vraiment le temps d'une image
2.1 L'instrumentation
src/main.cpp chronomètre désormais cinq postes CPU par image, journalisés à la
fermeture (Cout par image) : streaming terrain, gatherTrees, gatherGrass,
construction du tronc de vision, et drawFrame. Même démarche que
buildProfile en Phase 18, appliquée à l'image entière.
Le chronomètre est pris sans condition : un profilage qu'on active à la demande finit par mesurer un binaire différent de celui qui tourne. Coût mesuré : « tronc de vision » vaut 0,3 à 0,9 µs en Release, ce qui borne le coût des bornes elles-mêmes.
2.2 Ce que le Debug faisait croire
Vue d'alpage, Debug :
| Poste | µs/image |
|---|---|
gatherTrees |
1 747 |
gatherGrass |
4 944 |
drawFrame |
1 373 |
| Streaming terrain | 97 |
| Tronc de vision | 5 |
gatherTrees coûtait 1 630 à 1 936 µs dans les trois scénarios testés, y
compris le survol à 120 m d'altitude où les arbres sont à peine visibles. Coût
strictement constant, indépendant de ce qui est à l'écran : la signature d'un
coût de balayage, pas d'un coût de contenu. Deux redondances par image
étaient identifiées dans le code et prêtes à être corrigées :
- 5 appels à
terrain_.heightAt()par bloc de 8x8 cellules pour estimer ses bornes verticales, à chaque image, alors que ces bornes ne changent jamais (~720 appels par image) ; - la purge du cache parcourt les ~1 800 cellules du cache à chaque image pour y chercher des cellules à oublier, alors que la caméra bouge de quelques centimètres par image.
2.3 Ce que le Release dit, et qui annule tout ce qui précède
Mêmes vues, build Release :
| Poste | Alpage | Vue de référence |
|---|---|---|
drawFrame |
3 537 µs (81 %) | 1 424 µs (83 %) |
gatherGrass |
515 µs | 128 µs |
gatherTrees |
254 µs | 153 µs |
| Streaming terrain | 22 µs | 15 µs |
| Tronc de vision | 0,9 µs | 0,6 µs |
gatherTrees passe de 1 747 à 254 µs. La somme des postes (4 328 µs) rend
compte de la quasi-totalité de l'image mesurée (4,39 ms), donc rien d'important
n'échappe au profil.
2.4 Le frame est limité par le GPU — vérifié par ablation, pas affirmé
drawFrame inclut l'attente de la barrière de la frame en vol. Pour distinguer
« le CPU travaille » de « le CPU attend », on retire du travail GPU et on
regarde si les postes CPU bougent. Alpage, Release, 20 s :
| Images | drawFrame |
Arbres CPU | Herbe CPU | Temps/image | |
|---|---|---|---|---|---|
| Tout | 4 561 | 3 537 µs | 254 | 515 | 4,39 ms |
--no-grass |
7 184 | 2 537 µs | 185 | 0 | 2,78 ms |
--no-vegetation |
10 631 | 1 830 µs | 0 | 0 | 1,88 ms |
Retirer l'herbe économise 515 µs de CPU mais fait tomber le temps d'image de
1 610 µs : le gain vient du GPU, pas du CPU. Le CPU passe 81 % de l'image à
attendre dans drawFrame.
Conséquence directe : aucune optimisation CPU ne vaut la peine d'être faite
ici. Supprimer entièrement gatherTrees et gatherGrass — 769 µs sur 4 390 —
ne rendrait rien, puisque ce temps est déjà pris sur une attente. Les deux
redondances du §2.2 sont réelles et restent notées pour le jour où le
rapport de forces changera (GPU plus rapide, ou résolution plus basse) ; les
corriger aujourd'hui serait optimiser un artefact du build de test.
Conformément à la consigne — « n'implémente que ce qui est mesuré comme un vrai gain » — rien n'a été optimisé dans la Tâche 2. Ce qu'elle livre est le profileur permanent et la mesure qui réoriente le travail futur.
2.5 Une redondance réelle mais négligeable, signalée et non corrigée
renderer.projectionMatrix() * camera.viewMatrix() puis
Frustum::fromViewProjection sont calculés deux fois par image — une fois
pour le streaming, une fois pour la végétation. C'est bien une redondance, et
elle est maintenant mesurée : 0,3 à 0,9 µs par image en Release. La
supprimer n'est pas une optimisation, c'est du ménage ; elle n'a pas été faite
dans cette phase pour ne pas mélanger un changement non mesurable avec des
changements mesurés.
3. Résumé des chiffres
Vue de référence Phase 11 — E 901500 N 6436600, yaw 100, pitch -7 (Debug)
| État | FPS médian | Pic RAM |
|---|---|---|
| Phase 18 | 293 | 332,7 Mo |
| Après la Phase 19 | 311 | 331,7 Mo |
Vue d'alpage — E 900500 N 6439000, yaw 100, pitch -7 (Debug)
| État | FPS médian | Pic RAM |
|---|---|---|
| Phase 18 | 122 | 340,2 Mo |
| Après la Phase 19 | 131 | 339,1 Mo |
Ces écarts sont dans le bruit de la mesure de FPS (~15 % entre deux runs identiques, cf. MEMORY.md) : la phase ne prétend pas à un gain de FPS sur ces vues. Ce qui est solide, c'est le pic mémoire, qui est plus stable et qui est descendu de 1 Mo sur les deux vues.
Coût d'une tuile — survol 900 m/s
| Poste | Debug | Release |
|---|---|---|
| Géométrie | 1 344 µs (79 %) | 140 µs (33 %) |
| Indices | 16 µs | 15 µs |
| Téléversement | 250 µs (15 %) | 262 µs (63 %) |
0 tuile non couverte sur toutes les mesures, Debug comme Release, séquentiel comme parallèle.
4. Vérification
- Tests headless : 902 assertions (896 avant la phase, +6), toutes passent. Nouvelle section « Phase 19 : maillage de tuiles en parallèle » (§1.8).
- Zéro message
[Validation]sur la totalité des mesures et des scénarios, Debug et Release. VK_LAYER_VALIDATE_SYNC=1sur les deux chemins : 0 message, avec son contrôle négatif (§1.9).- Harnais
run_vulkan_check.ps1: voir §4.1.
4.1 Résultat du harnais
Joué deux fois en entier (11 processus, scénarios A à I) : une fois après la Tâche 1, une fois sur le binaire final.
- 0 message
[Validation], 0 ligne[ERROR], code de sortie 0 pour chacun des onze processus, fermeture propre partout ; - gameplay effectivement exercé : 2 arbres abattus (3 au sol), 3 débitages, 4 objets ramassés, percussion, vol de parapente complet, escalade avec sommet atteint (+41,5 m, pente 65 à 155 %), éditeur (3 objets posés, un supprimé, une annulation, sauvés/rechargés, et rechargés en partie normale où ils arrêtent le joueur : 0,28 m parcourus contre 21,05 m pour le témoin sans scène), boisson au point d'eau avec son contrôle négatif à 30 m, faune qui se retire du voisinage (4 animaux à portée au premier relevé → 0 au dernier).
Les 4 lignes [WARN] sont les avertissements bénins habituels (pas de point
d'eau ni de faune sur certaines dalles) ; le harnais ne les compte pas comme des
erreurs.
Le point rouge, inchangé depuis la Phase 17
Le harnais sort en [ECHEC] sur un seul critère : scénario E (vélo),
« pied à terre » (False). C'est un échec antérieur à cette phase, documenté
dans NOTES-PHASE17.md puis dans NOTES-PHASE18.md §4, laissé non corrigé pour
cause de périmètre. La Phase 19 ne l'a ni causé ni aggravé — elle ne touche que
le maillage des tuiles de terrain, et le reste du scénario E est vert (en selle
True, 13 relevés à l'arrêt en côte au-delà de 23,6 % de pente).
Le scénario I, bruité en Phase 18, est vert cette fois (4 → 0).
5. Options et outils ajoutés
| Ajout | Rôle |
|---|---|
--tile-threads=N |
Degré de parallélisme du maillage CPU des tuiles, thread de rendu compris. Défaut 1 (séquentiel). Témoin de mesure : aucun appel Vulkan ne change de thread quelle que soit la valeur. |
tools\profile_tiles.ps1 |
Relève le profil de construction des tuiles et le coût par image sur un scénario donné. La Phase 18 relevait ces lignes à la main ; ce script rend le relevé reproductible — ce que measure_terrain.ps1 avait fait pour le FPS en Phase 9. |
Journal Cout par image |
Cinq postes CPU du frame, à la fermeture. Permanent, non conditionnel. |
Journal Maillage parallele |
Temps de mur et travail cumulé du maillage, dans buildProfile. Les deux, jamais un seul (§1.3). |
6. Prochaines étapes suggérées
- Refaire les mesures de performance des phases précédentes en Release. C'est la conséquence la plus large de cette phase : les priorités d'optimisation du projet sont établies sur des profils de Debug, et on vient de voir qu'au moins l'une d'elles ne survit pas au passage en Release. Les conclusions des Phases 10, 11, 12 et 18 méritent une relecture sous cet angle.
- Le vrai poste d'une tuile en Release est le TÉLÉVERSEMENT (63 %). La piste chiffrée existe déjà et n'a pas bougé : partager un unique buffer d'indices GPU entre toutes les tuiles (Phase 18 §2.5) supprimerait 96 Ko de copie par tuile et ~48 Mo de mémoire GPU. C'est désormais le chantier de performance le mieux ciblé.
- Le frame est limité par le GPU, et le premier consommateur est la
végétation : sur l'alpage, l'herbe pèse 1,0 ms et les arbres 0,7 ms des
3,5 ms de
drawFrame. Le levier est le nombre d'instances, pas le shader (la Phase 18 avait déjà montré que la découpe alpha coûte zéro). Un LOD sur l'herbe — moins de touffes au-delà de 20 m — serait le gain le plus important disponible aujourd'hui, mais il touche la qualité visuelle : c'est un compromis à valider, pas une optimisation à décider seul. - Les deux redondances de
gatherTrees(§2.2), si le rapport CPU/GPU change un jour. - Rendre les scénarios E et I du harnais insensibles au FPS (hérité de la Phase 18, toujours pas fait).