Fichiers
vercora/NOTES-PHASE30.md
T
Claude be8ce19a73 Phase 30 (6/n) : bilan, robustesse des televersements, notes
- Renderer : un maillage possede ses plages des leur reservation
  (allocateMesh) et ses copies ne sont confiees a l'image suivante
  qu'une fois toutes ses ecritures reussies - plus de plage perdue ni de
  copie visant une plage rendue si la memoire vient a manquer.
- Ligne "Ressources (PHASE 30)" : bilan du pool de geometrie.
- main.cpp : le C4244 connu de la Phase 27 rendu explicite.
- NOTES-PHASE30.md : execution, bilan chiffre avant/apres sur les trois
  scenarios, verification (images, validation standard et de
  synchronisation, controle negatif), limites, reproduction.
- MEMORY.md : section Phase 30.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
2026-10-13 23:44:17 +00:00

Phase 30 - Optimisation des ressources (memoire GPU, RAM, allocations, CPU)

Session du 2026-10-13, en environnement cloud (Linux, sans GPU). Demande : un plan d'optimisation des ressources "a l'octet pres", une revue du noyau moteur et Vulkan, un banc de mesure, l'execution du plan, puis une re-mesure.

Ce fichier a deux parties : le PLAN (ecrit avant de toucher au moteur, avec la mesure de reference) et le BILAN (apres execution, meme banc). Detail des chiffres bruts : section "Banc de mesure".


1. Comment mesurer sans la machine de developpement

Pas de GPU, pas de Windows, pas de donnees LiDAR (le proxy reseau refuse data.geopf.fr). Il a donc fallu :

  • Builder sous Linux. Deux defauts de portabilite l'empechaient :
    • Heightmap(const Params& = {}), TerrainQuadtree(..., const Params& = {}) et TerrainStreamer(..., const Params& = {}) : un argument par defaut qui construit une struct IMBRIQUEE a initialiseurs de membres est refuse par GCC et Clang (CWG 1397), accepte par MSVC. Remplace par une surcharge qui delegue (meme semantique, explicit conserve).
    • <GLFW/glfw3.h> incluait <GL/gl.h> (present avec le SDK Windows, absent sans libgl-dev sous Linux). GLFW_INCLUDE_NONE ajoute a cote de GLFW_INCLUDE_VULKAN. Le projet compile desormais sans avertissement nouveau avec GCC 13 (Release et Debug), et les tests headless passent avec Clang 18.
  • Un GPU logiciel : lavapipe (Mesa 25.2, Vulkan 1.4) sous Xvfb 1280x720. Les couches de validation Khronos tournent dessus. Le rendu y est DETERMINISTE : deux executions identiques donnent 0 pixel different, ce qui permet de prouver au bit pres qu'une optimisation ne change pas l'image.
  • Une zone proxy a la vraie echelle : tools/make_bench_zone.py ecrit un relief fBm de 5001 x 5001 au pas de 1 m avec la georeference et la plage d'altitudes de la vraie zone (l'orthophoto versionnee s'y applique), et des cartes de couvert tirees de l'orthophoto elle-meme. Le quadtree (8 380 noeuds), le streaming, la vegetation et tous les budgets memoire y travaillent a la vraie echelle. Le relief n'est pas le Vercors : les chiffres sont comparables ENTRE EUX (avant/apres), pas a ceux de l'UHD 770.

Outillage ajoute au jeu pour ce banc (et utilisable sur la machine de dev) :

ajout role
VulkanContext::allocateMemory / freeMemory TOUTE la memoire GPU passe par le contexte, qui la compte : octets vivants, pics, blocs vivants, appels vkAllocateMemory
core/ProcessMemory RAM residente et pic du processus, lus au systeme (/proc/self/status sous Linux, GetProcessMemoryInfo sous Windows)
ligne Ressources ... (PHASE 30) au chargement, toutes les 10 s, et en fin de partie (pics de session)
--quit-after=S fermeture propre apres S s de boucle : tous les bilans sont ecrits (remplace le WM_CLOSE poste de l'exterieur)
--freeze-anim fige l'horloge d'animation des shaders (herbe, pluie) : images comparables au pixel

Scenarios (Release, --lock-input --hour=13 --time-scale=0 --freeze-anim, 30 s de boucle, deux passages chacun) :

  • foret : a pied dans la foret sud (--start=901800,6435800 --look=0,-8) ;
  • panorama : depuis le point culminant, vue lointaine sur la zone (--start=900175,6438524 --look=45,-6) ;
  • survol : --flythrough=900,120, le cas de stress du streaming.

2. Mesure de reference (avant toute optimisation)

foret panorama survol
memoire GPU en fin de partie 75,0 Mo 71,6 Mo 251-256 Mo
pic memoire GPU 102,6 Mo 96,6 Mo 283-286 Mo
dont geometrie de terrain (pic) 27 Mo / 74 tuiles 24 Mo / 67 tuiles 188 Mo / 512 tuiles
blocs vkAllocateMemory vivants (pic) 436 408 1 374
appels vkAllocateMemory sur la session 439 411 ~17 000
construction d'une tuile (geometrie + televersement) 167 + 210 us 194 + 207 us 202 + 219 us
streaming terrain, CPU par image 119 us 58 us 4,1-4,5 ms
RAM (pic, lavapipe compris) 463 Mo 353 Mo 606 Mo
images/s (lavapipe, CPU) 8,2 19,5 14,5

Validation : 0 message sur les trois scenarios (Debug + couches Khronos).

Repartition de la RAM du moteur (heaptrack, scenario foret) : la heightmap 1 m (100 Mo de float) et les quatre cartes de vegetation (16 Mo) font l'essentiel ; tout le reste du moteur (quadtree 1 Mo, caches de vegetation < 1 Mo, maillages CPU transitoires) pese moins de 3 Mo. Le reste du processus est lavapipe lui-meme (tramage logiciel, JIT LLVM) et n'existe pas sur l'UHD 770.

3. Revue du noyau moteur et Vulkan

Ce qui est BIEN et ne bouge pas :

  • synchronisation : 2 images en vol, semaphore de fin de rendu par image de swapchain, fences, dependance de subpass corrigee en Phase 12 - correct ;
  • une seule soumission par image, copies enregistrees en tete du command buffer avec UNE barriere (Phase 12) - le bon choix sur un GPU sans file de transfert dediee ;
  • descriptor sets alloues une fois, aucun vkUpdateDescriptorSets par image ;
  • push constants pour le par-objet, instanciation pour la vegetation, orthophoto deja en BC1 avec mipmaps precalculees ;
  • aucune allocation de tas notable par image cote moteur (heaptrack).

Ce qui COUTE, par ordre d'importance mesuree :

  1. Le format de sommet unique de 68 octets. Tout passe par Vertex (position, couleur, normale, UV, et 24 octets de cible de geomorphing). Une tuile de terrain = 4 225 sommets x 68 o = 287 Ko, alors que le terrain n'a besoin que de DEUX altitudes et DEUX normales par sommet : x, z et UV se deduisent de l'indice du sommet, la couleur est constante (blanc). Les maillages d'objets, eux, portent 24 octets de morphing qu'aucun de leurs shaders ne lit.
  2. Une topologie recopiee par tuile. Les 24 576 indices sont identiques pour toutes les tuiles (l'en-tete de TerrainNodeMesh le dit depuis la Phase 10) mais chaque tuile en televerse sa copie : 96 Ko par tuile, en uint32 alors que 4 225 sommets tiennent en uint16.
  3. Une allocation Vulkan par buffer. 2 par maillage, plus 2 de staging par televersement : ~17 000 vkAllocateMemory en 30 s de survol. C'est un appel noyau sous Windows (WDDM), arrondi a sa granularite d'allocation, et plafonne par maxMemoryAllocationCount (souvent 4 096) - le plafond de 512 tuiles residentes n'existait que pour lui.
  4. Un staging inutile en memoire unifiee. Sur l'UHD 770 (et lavapipe), la memoire device-local EST mappable : ecrire la tuile directement la ou le GPU la lit evite un buffer staging, une copie GPU et une barriere par tuile.
  5. Le chargement de l'orthophoto tient trois copies de 42 Mo en meme temps (fichier lu en RAM, staging, image GPU).
  6. Le terrain est dessine AVANT la vegetation, sans culling des faces arriere : en foret, le shader de terrain (le plus lourd du jeu) est execute pour des pixels que les troncs et houppiers recouvrent ensuite.
  7. La construction d'une tuile lit chaque altitude ~6 fois (cinq lectures ecretees par echantillon, plus la grille du parent).

4. Le plan

Chaque point dit ce qu'il gagne, ce qu'il risque, et COMMENT on prouve qu'il ne casse rien. Regle du projet appliquee : ce qui doit etre invisible est verifie AU PIXEL PRES contre la reference (lavapipe est deterministe) ; ce qui change l'image est chiffre en pixels touches et en ecart maximal.

# chantier gain attendu image preuve
P1 Terrain : sommet compact 16 o (2 altitudes f32 + 2 normales snorm16), x/z/UV deduits de l'indice du sommet, indices PARTAGES en uint16 geometrie terrain -82 % (385 Ko -> 68 Ko par tuile) normales quantifiees a 3e-5 pres : ecart d'arrondi tests : altitudes au bit pres, normales a 1/32767 pres ; captures
P2 Pool de sous-allocation (blocs de 4 Mo, premier ajustement) pour TOUTE la geometrie, liberation differee comme avant ~17 000 -> quelques dizaines d'allocations ; fin des petits blocs aucun captures au bit pres ; validation
P3 Ecriture DIRECTE en memoire unifiee (GPU integre/CPU), staging conserve sur GPU discret (--force-staging pour l'eprouver) plus de staging ni de copie par tuile aucun captures identiques dans les deux modes
P4 Maillages d'objets : format GPU de 44 o (sans les 24 o de morphing), exact -35 % sur ces maillages aucun au bit pres
P5 Orthophoto lue directement dans le staging -42 Mo de pic RAM au chargement, une copie de 42 Mo en moins aucun au bit pres
P6 Ordre de dessin objets -> vegetation -> terrain (early-Z) + culling des faces arriere du terrain moins de fragments de terrain ombres aucun (opaque, test LESS) au bit pres
P7 Tuile : altitudes lues UNE fois (grille bordee), chemin de reference garde pour les bords geometrie de tuile ~-50 % CPU aucun test : bit a bit identique a la reference sur toutes les tuiles

NON RETENU, et pourquoi :

  • Quantifier la heightmap (100 Mo -> 50 Mo en uint16) : elle est la verite PHYSIQUE (collision, marche, velo, escalade, semis). Les altitudes ne sont pas des centimetres ronds (mediane paire, bouchage, raccords de dalles) : il n'existe pas de codage 16 bits sans perte. 100 Mo est le prix de l'exactitude.
  • Cartes de vegetation en uint8 (16 -> 4 Mo) : le semis est deterministe et compare la densite a des seuils ; quantifier deplacerait des arbres.
  • InstanceData 28 -> 20 o : variation porte un entier code (gradient des rochers, Phase 29) qui ne survit pas a un demi-flottant ; le gain (~100 Ko par image) ne vaut pas le risque.
  • Abandonner le niveau 0 de l'orthophoto (-32 Mo) : 0,61 -> 1,22 m/texel, une perte de qualite visible a pied.
  • Tirer les altitudes d'un SSBO (vertex pulling, 16 -> ~4,5 o/sommet) : 25 Mo de mieux au pic du survol, pour un changement de modele d'entree, un descripteur de plus et un shader a bords exacts. A reprendre si le pas LiDAR s'affine.

5. Execution : ce qui a ete fait

Cinq commits sur la branche, chacun valide avant le suivant (tests headless, couches de validation Khronos, comparaison d'images au pixel pres).

P6 - ordre de dessin et culling (Renderer, Pipeline)

  • Ordre objets -> vegetation -> TERRAIN (kDrawOrder). Le shader de fragment du terrain est le plus lourd du jeu ; dessine en dernier, ses fragments caches par les troncs et l'herbe sont ecartes par le test de profondeur precoce. Foret : -26 % de temps de rendu a lui seul.
  • ShaderSet::cullBackFaces, terrain seulement (champ de hauteurs : un oeil au-dessus du relief rencontre toujours une face avant d'abord). frontFace = COUNTER_CLOCKWISE une fois l'axe Y de la projection retourne, verifie par le calcul d'aire de la spec ET a l'image.

P1 a P4 - geometrie compacte et pool (GpuVertex, GpuBufferPool, Mesh)

  • renderer/GpuVertex.hpp : ObjectVertex (44 o, conversion exacte de Vertex) et TerrainVertex (16 o : altitude, altitude cible, normales x/z en snorm16). Vertex (68 o) reste le format de TRAVAIL cote CPU : aucun generateur ni aucun test n'a change de format.
  • terrain.vert recalcule x/z, la cible de morphing et l'UV depuis gl_VertexIndex et DrawItem::grid (ix0, iz0, pas, sommets par rangee) + UniformBufferObject::terrainGrid (origine, pas, cellules). precise interdit la fusion en FMA : les positions sont celles de Heightmap::worldCoord au bit pres (verifie en C++ par les tests).
  • Topologie des tuiles televersee UNE fois en uint16 (addSharedIndices) ; indices des objets en uint16 ; une seule liaison d'indices par image pour tout le terrain (bindMesh saute les liaisons redondantes).
  • GpuBufferPool (blocs de 4 Mo, RangeAllocator premier ajustement, bloc dedie au-dela d'un demi-bloc, un bloc vide garde en reserve) : un Mesh ne possede plus de buffer mais des PLAGES, rendues au pool par le meme retrait differe qu'avant (kMaxFramesInFlight + 1 images).
  • Memoire unifiee + GPU integre ou logiciel (preferDirectGeometryWrites) : blocs mappes, la geometrie est ECRITE la ou le GPU la lit - ni staging, ni copie, ni barriere. GPU discret : staging de la Phase 12, avec une barriere d'execution VERTEX_INPUT -> TRANSFER avant les copies (une plage recyclee a ete lue par des images precedentes). --force-staging eprouve ce chemin.
  • writeTerrainNodeVertices : les sommets d'une tuile ecrits directement au format compact (plus de MeshData de 287 Ko par tuile, plus de copie). terrainNodeMeshData reste la reference testee : les deux partagent le meme parcours (forEachNodeVertex), ils ne peuvent pas diverger.
  • --no-lod : terrainGpuMeshData produit directement le format compact (1,7 Go de MeshData en moins au pic sur la zone au pas de 1 m).

P5 - orthophoto (TextureFile, Texture)

  • loadTextureFileHeader + readTexturePayload (entier ou par tranche) ; loadTextureFile en est la composition.
  • Texture remplit son staging par une source et le REUTILISE par bandes de rangees de blocs (4 Mo au plus) au lieu d'un staging de toute la chaine. L'orthophoto n'est plus jamais tenue en RAM.

P7 - construction des tuiles interieures (TerrainNodeMesh)

  • Loin du bord, les altitudes sont lues une fois dans une grille bordee de deux rangs, puis les MEMES operations flottantes que sampleGrid. Bords et temoin --no-tile-cache : chemin de reference.

En plus du plan

  • --vsync : presentation FIFO. Le plus gros levier de CONSOMMATION (378 images/s sur l'UHD 770 = GPU a 100 % pour un ecran a 60 Hz). Non active par defaut : les mesures du projet comptent des images non plafonnees.
  • Ligne Ressources (PHASE 30) completee par le bilan du pool de geometrie.
  • Televersements surs en cas d'echec d'allocation : le Mesh possede ses plages des leur reservation, et aucune copie n'est confiee a l'image suivante avant que toutes les ecritures du maillage aient reussi.
  • Le C4244 connu de main.cpp (Phase 27, groundDetailPattern) : conversion rendue explicite, meme valeur.

6. Bilan chiffre (meme banc, memes scenarios, moyenne de 2 passages)

Release, lavapipe, 1280 x 720, zone proxy. "RAM" inclut ici la memoire GPU (lavapipe l'alloue dans le processus) : sur l'UHD 770 elle n'y figure pas.

foret avant foret apres panorama avant panorama apres survol avant survol apres
memoire GPU, fin de partie 75,0 Mo 55,5 Mo 71,6 Mo 54,6 Mo 254 Mo 86,7 Mo
memoire GPU, pic de session 102,6 Mo 55,5 Mo 96,6 Mo 54,6 Mo 285 Mo 86,7 Mo
dont geometrie de terrain (pic) 27 Mo 4 Mo 24 Mo 4 Mo 188 Mo 33 Mo
blocs vkAllocateMemory vivants (pic) 436 10 408 10 1 366 18
appels vkAllocateMemory (session) 439 13 411 13 ~16 950 22
pic RAM au chargement 302 Mo 233 Mo 302 Mo 234 Mo 302 Mo 234 Mo
pic memoire GPU au chargement 89,2 Mo 50,5 Mo 89,2 Mo 50,5 Mo 89,2 Mo 50,5 Mo
temps de chargement 0,48 s 0,38 s 0,47 s 0,38 s 0,47 s 0,38 s
pic RAM de session 463 Mo 409 Mo 353 Mo 312 Mo 605 Mo 374 Mo
tuile : geometrie 167 us 142 us 194 us 139 us 202 us 105 us
tuile : televersement 210 us 0,5 us 207 us 0,6 us 219 us 0,7 us
streaming terrain, CPU par image 119 us 45 us 58 us 35 us 4,3 ms 0,93 ms
temps de rendu (drawFrame) 120 ms 83 ms 51 ms 43 ms 62 ms 52 ms
images/s (lavapipe) 8,2 11,8 (+44 %) 19,4 22,7 (+17 %) 14,6 18,0 (+24 %)

Les images/s et le temps de rendu sont ceux d'un GPU LOGICIEL : ils disent le sens et l'ordre de grandeur du gain (moins de fragments de terrain ombres, moins d'octets lus par sommet), pas le chiffre de l'UHD 770. Les octets, les allocations et les couts CPU de construction, eux, ne dependent pas du GPU.

Maillages d'objets (27 maillages, 4 070 sommets, 1 504 triangles) : 295 Ko -> 188 Ko (-36 %), en 1 bloc au lieu de 54 allocations (et 54 de staging).

7. Verification

  • Tests headless : 3 963 / 3 963 (3 943 avant : +20 verifications), compiles avec GCC 13 (0 avertissement en -Wall -Wextra) et Clang 18. Les 25 verifications qui ont besoin des vraies dalles LiDAR sont ignorees ici, comme toujours sans elles.
  • Validation Khronos (Debug) : 0 message sur foret, panorama et survol ; validation de synchronisation : 0 message, chemins direct ET staging. Controle negatif : sans la barriere VERTEX_INPUT -> TRANSFER, 414 messages SYNC-HAZARD-WRITE-AFTER-READ en 30 s de survol avec --force-staging.
  • Images (sans faune : les animaux bougent en temps reel, leur position depend du nombre d'images rendues) :
    • foret : 353 pixels sur 921 600 (0,038 %) ; 329 a +/- 1 niveau (normales quantifiees) et 24 aux pieds des brins et des troncs, la ou leur profondeur EGALE celle du sol. Preuve : une variante qui rend ces egalites au terrain redonne l'image de reference au bit pres ;
    • panorama : 1 149 pixels (0,125 %), dont ~250 isoles sur les parois quasi verticales vues en rasant (culling, voir ShaderSet::cullBackFaces) ;
    • chemin staging (--force-staging), maillage parallele (--tile-threads=4), orthophoto par tranches, chemin rapide des tuiles : chacun IDENTIQUE au bit pres au chemin qu'il remplace ;
    • --no-lod et LOD : identiques entre eux sur le terrain synthetique.

8. Ce qui reste, et pour qui

  • A re-mesurer sur l'UHD 770 : les images/s Release (profile_phase27.ps1, profile_phase29.ps1) et run_vulkan_check.ps1 complet. Les lignes Ressources (PHASE 30) donnent desormais la memoire GPU exacte dans le journal de chaque scenario.
  • Staging sur GPU discret : un staging (une allocation) par televersement, comme avant la phase. Un anneau de staging persistant ramenerait ce chemin au niveau du chemin direct ; non ecrit faute de GPU discret pour l'eprouver.
  • Vertex pulling du terrain (16 -> ~4,5 o par sommet) : 25 Mo de mieux au pic du survol. Voir section 4.
  • Cache de pipelines (VkPipelineCache sur disque) : demarrage plus rapide sur un pilote sans cache propre ; le pilote Intel en a un.
  • CPU par image : le profil (perf) ne montre plus que le semis de l'herbe et des arbres (Phase 18) ; rien d'autre au-dessus du bruit.

9. Reproduire

# Linux : dependances (Ubuntu 24.04)
apt-get install mesa-vulkan-drivers libvulkan-dev glslc vulkan-validationlayers \
    ninja-build libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev \
    libxkbcommon-dev xvfb imagemagick python3-numpy
cmake -S . -B build-rel -G Ninja -DCMAKE_BUILD_TYPE=Release -DGLFW_BUILD_WAYLAND=OFF
ninja -C build-rel
python3 tools/make_bench_zone.py          # sans les vraies donnees seulement
Xvfb :99 -screen 0 1280x720x24 &
DISPLAY=:99 VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.json \
    build-rel/vercora assets/terrain/vercora_zone_1m.vchm --lock-input \
    --hour=13 --time-scale=0 --freeze-anim --start=901800,6435800 \
    --look=0,-8 --quit-after=30
# puis lire les lignes "Ressources", "Cout par image", "Construction de tuiles"
# validation de synchronisation : Debug + VK_LAYER_ENABLES=
#   VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT