Phase 30 (1/n) : build Linux, banc de mesure des ressources, plan
- Portabilite GCC/Clang : les constructeurs a argument par defaut `= {}`
sur une struct imbriquee (Heightmap, TerrainQuadtree, TerrainStreamer)
deviennent des surcharges qui deleguent (CWG 1397, refuse hors MSVC).
GLFW_INCLUDE_NONE evite d'exiger <GL/gl.h> sous Linux.
- Comptabilite de la memoire GPU : toute allocation passe par
VulkanContext::allocateMemory / freeMemory (octets vivants, pics, blocs,
appels vkAllocateMemory). RAM du processus lue au systeme
(core/ProcessMemory). Bilan "Ressources (PHASE 30)" au chargement,
toutes les 10 s et en fin de partie.
- Outils de banc : --quit-after=S (fermeture propre), --freeze-anim
(images comparables au pixel), tools/make_bench_zone.py (zone proxy
5001x5001 a la vraie echelle quand les donnees LiDAR sont absentes).
- NOTES-PHASE30.md : mesure de reference, revue du noyau Vulkan, plan.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
Cette révision appartient à :
1 Parent
84a72fe30c
révision
16775bf1ff
17 fichiers modifiés
+767
-59
Aucun fichier ne correspond à votre recherche
@@ -75,6 +75,7 @@ add_executable(vercora
|
||||
src/core/Window.cpp
|
||||
src/core/Camera.cpp
|
||||
src/core/Paths.cpp
|
||||
src/core/ProcessMemory.cpp
|
||||
src/assets/ObjLoader.cpp
|
||||
src/assets/Heightmap.cpp
|
||||
src/assets/TerrainFile.cpp
|
||||
@@ -138,12 +139,17 @@ target_link_libraries(vercora PRIVATE
|
||||
)
|
||||
|
||||
# GLFW_INCLUDE_VULKAN : GLFW inclut les headers Vulkan automatiquement.
|
||||
# GLFW_INCLUDE_NONE : ... et PAS <GL/gl.h>, qu'il inclut sinon par defaut. Le
|
||||
# moteur ne fait aucun OpenGL ; sous Windows l'en-tete vient avec le SDK et le
|
||||
# defaut passait inapercu, mais sous Linux il exige les en-tetes Mesa
|
||||
# (libgl-dev) pour rien. Les deux macros se combinent (voir glfw3.h).
|
||||
# VERCORA_DEBUG : active les validation layers uniquement en configuration Debug.
|
||||
# GLM_FORCE_RADIANS : GLM travaille en radians (evite les surprises d'unites).
|
||||
# GLM_FORCE_DEPTH_ZERO_TO_ONE : Vulkan attend une profondeur clip dans [0,1]
|
||||
# (et non [-1,1] comme OpenGL) -> indispensable pour un depth buffer correct.
|
||||
target_compile_definitions(vercora PRIVATE
|
||||
GLFW_INCLUDE_VULKAN
|
||||
GLFW_INCLUDE_NONE
|
||||
GLM_FORCE_RADIANS
|
||||
GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||||
$<$<CONFIG:Debug>:VERCORA_DEBUG>
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
# 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.
|
||||
@@ -95,7 +95,14 @@ public:
|
||||
// Genere immediatement la grille par bruit fractal. Lance
|
||||
// std::runtime_error si les parametres ne peuvent pas produire une surface
|
||||
// (resolution < 2, taille <= 0, ...).
|
||||
explicit Heightmap(const Params& params = {});
|
||||
explicit Heightmap(const Params& params);
|
||||
|
||||
// Memes parametres par defaut. Une SURCHARGE plutot qu'un argument par
|
||||
// defaut `= {}` : GCC et Clang refusent de construire une struct IMBRIQUEE
|
||||
// dotee d'initialiseurs de membres dans un argument par defaut de la classe
|
||||
// englobante (CWG 1397), la ou MSVC l'accepte. Le corps d'une fonction
|
||||
// membre, lui, voit la classe complete : la delegation compile partout.
|
||||
explicit Heightmap() : Heightmap(Params{}) {}
|
||||
|
||||
// Adopte une grille DEJA CONSTRUITE, sans rien generer : c'est par ici
|
||||
// qu'entrent les donnees LiDAR (voir assets/TerrainFile.hpp).
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
#include "core/ProcessMemory.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
#if defined(_WIN32)
|
||||
# ifndef WIN32_LEAN_AND_MEAN
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# endif
|
||||
# ifndef NOMINMAX
|
||||
# define NOMINMAX
|
||||
# endif
|
||||
# include <windows.h>
|
||||
// Avec PSAPI_VERSION 2 (le defaut depuis Windows 7), GetProcessMemoryInfo est
|
||||
// K32GetProcessMemoryInfo, exportee par kernel32 : aucune bibliotheque de plus
|
||||
// a lier.
|
||||
# include <psapi.h>
|
||||
#elif defined(__linux__)
|
||||
# include <fstream>
|
||||
# include <sstream>
|
||||
#endif
|
||||
|
||||
namespace vercora {
|
||||
|
||||
ProcessMemory processMemory() {
|
||||
ProcessMemory memory;
|
||||
#if defined(_WIN32)
|
||||
PROCESS_MEMORY_COUNTERS counters{};
|
||||
if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) {
|
||||
memory.residentBytes = static_cast<uint64_t>(counters.WorkingSetSize);
|
||||
memory.peakResidentBytes = static_cast<uint64_t>(counters.PeakWorkingSetSize);
|
||||
memory.available = true;
|
||||
}
|
||||
#elif defined(__linux__)
|
||||
// Lignes "VmRSS: 123456 kB" et "VmHWM: 234567 kB".
|
||||
std::ifstream status("/proc/self/status");
|
||||
std::string line;
|
||||
while (std::getline(status, line)) {
|
||||
const bool rss = line.rfind("VmRSS:", 0) == 0;
|
||||
const bool hwm = line.rfind("VmHWM:", 0) == 0;
|
||||
if (!rss && !hwm) {
|
||||
continue;
|
||||
}
|
||||
std::istringstream fields(line.substr(6));
|
||||
uint64_t kilobytes = 0;
|
||||
fields >> kilobytes;
|
||||
(rss ? memory.residentBytes : memory.peakResidentBytes) = kilobytes * 1024u;
|
||||
memory.available = true;
|
||||
}
|
||||
#endif
|
||||
return memory;
|
||||
}
|
||||
|
||||
std::string processMemoryLine() {
|
||||
const ProcessMemory memory = processMemory();
|
||||
if (!memory.available) {
|
||||
return "RAM non mesuree (plateforme non prise en charge)";
|
||||
}
|
||||
char text[96];
|
||||
std::snprintf(text, sizeof(text), "RAM %.1f Mo (pic %.1f Mo)",
|
||||
static_cast<double>(memory.residentBytes) / (1024.0 * 1024.0),
|
||||
static_cast<double>(memory.peakResidentBytes) / (1024.0 * 1024.0));
|
||||
return text;
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
@@ -0,0 +1,31 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
namespace vercora {
|
||||
|
||||
// PHASE 30. Memoire RESIDENTE du processus, lue au systeme : ce que le
|
||||
// gestionnaire des taches appelle "jeu de travail" sous Windows, VmRSS sous
|
||||
// Linux. Le pic est celui de toute la vie du processus (PeakWorkingSetSize,
|
||||
// VmHWM).
|
||||
//
|
||||
// Jusqu'ici la RAM ne se mesurait que de l'EXTERIEUR (scripts PowerShell qui
|
||||
// interrogent le processus a intervalles fixes, donc qui ratent les pics
|
||||
// courts). Le jeu la journalise desormais lui-meme, au demarrage, en cours de
|
||||
// partie et a la fermeture - le meme principe que le bilan de streaming.
|
||||
//
|
||||
// Sur une memoire UNIFIEE (GPU integre, lavapipe), la memoire GPU allouee peut
|
||||
// apparaitre dans ce chiffre : le lire a cote de VulkanContext::gpuMemoryLine.
|
||||
struct ProcessMemory {
|
||||
uint64_t residentBytes = 0;
|
||||
uint64_t peakResidentBytes = 0;
|
||||
bool available = false; // false = plateforme non prise en charge
|
||||
};
|
||||
|
||||
ProcessMemory processMemory();
|
||||
|
||||
// "RAM 512.3 Mo (pic 734.0 Mo)", ou "RAM non mesuree" hors plateforme connue.
|
||||
std::string processMemoryLine();
|
||||
|
||||
} // namespace vercora
|
||||
+70
-6
@@ -11,6 +11,7 @@
|
||||
#include "editor/AssetCatalog.hpp"
|
||||
#include "editor/EditorController.hpp"
|
||||
#include "core/Paths.hpp"
|
||||
#include "core/ProcessMemory.hpp"
|
||||
#include "editor/EditorScene.hpp"
|
||||
#include "editor/PlacedObject.hpp"
|
||||
#include "editor/SceneFile.hpp"
|
||||
@@ -137,6 +138,13 @@ namespace {
|
||||
// objets poses, eux, font partie du monde et sont affiches et solides dans le
|
||||
// jeu normal - c'est justement le point.
|
||||
//
|
||||
// Plus deux options de la Phase 30, pour le BANC DE MESURE (voir NOTES-PHASE30.md) :
|
||||
// vercora.exe [scene] --quit-after=S -> fermeture propre apres S secondes
|
||||
// de boucle, bilans de fin compris
|
||||
// vercora.exe [scene] --freeze-anim -> horloge d'animation des shaders
|
||||
// figee : images comparables au
|
||||
// pixel pres d'un run a l'autre
|
||||
//
|
||||
// Le terrain synthetique n'est PAS supprime, et pour deux raisons distinctes :
|
||||
// il reste la scene de reference des tests (monde deterministe, arbres a
|
||||
// positions connues, cf. dumpWorld plus bas), et il sert de repli si le
|
||||
@@ -873,6 +881,20 @@ int main(int argc, char** argv) {
|
||||
std::string sceneFileArgument;
|
||||
std::string editorAssetsArgument;
|
||||
std::string sceneArgument;
|
||||
// PHASE 30 : outils de BANC DE MESURE.
|
||||
// --quit-after=S ferme proprement le jeu apres S secondes de boucle,
|
||||
// comme une fermeture de fenetre : tous les bilans de
|
||||
// fin de partie sont ecrits. Remplace le WM_CLOSE poste
|
||||
// de l'exterieur, que la Phase 26 a vu arriver en retard
|
||||
// sur une machine chargee.
|
||||
// --freeze-anim fige l'horloge d'ANIMATION des shaders (ondulation
|
||||
// de l'herbe, chute de la pluie) a zero. Avec
|
||||
// --lock-input, --look et --time-scale=0, deux images
|
||||
// d'une meme scene deviennent comparables au pixel pres,
|
||||
// ce qui est la condition pour prouver qu'une
|
||||
// optimisation ne change pas l'image.
|
||||
float quitAfterSeconds = 0.0f;
|
||||
bool freezeAnimation = false;
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
const std::string argument = argv[i];
|
||||
if (argument == "--dump-world") {
|
||||
@@ -1029,6 +1051,20 @@ int main(int argc, char** argv) {
|
||||
}
|
||||
} else if (argument.rfind("--ortho=", 0) == 0) {
|
||||
orthoArgument = argument.substr(std::strlen("--ortho="));
|
||||
} else if (argument.rfind("--quit-after=", 0) == 0) {
|
||||
try {
|
||||
quitAfterSeconds =
|
||||
std::stof(argument.substr(std::strlen("--quit-after=")));
|
||||
if (!(quitAfterSeconds > 0.0f)) {
|
||||
logWarn("--quit-after attend une duree positive en secondes. Ignore.");
|
||||
quitAfterSeconds = 0.0f;
|
||||
}
|
||||
} catch (const std::exception&) {
|
||||
logWarn("--quit-after : duree illisible. Ignore : " + argument);
|
||||
quitAfterSeconds = 0.0f;
|
||||
}
|
||||
} else if (argument == "--freeze-anim") {
|
||||
freezeAnimation = true;
|
||||
} else if (argument.rfind("--", 0) == 0) {
|
||||
logWarn("Option inconnue, ignoree : " + argument);
|
||||
} else if (sceneArgument.empty()) {
|
||||
@@ -2289,9 +2325,28 @@ int main(int argc, char** argv) {
|
||||
// fenetre, dont la Phase 18 a montre qu'il varie de ~15 % entre deux
|
||||
// runs identiques. Chargement exclu : il precede la boucle.
|
||||
const auto loopStart = ProfileClock::now();
|
||||
// PHASE 30 : bilan des ressources une fois le monde charge, avant la
|
||||
// premiere image. Le meme bilan est ecrit toutes les 10 s, puis a la
|
||||
// fermeture avec les pics de la session.
|
||||
logInfo("Ressources apres chargement (PHASE 30) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ".");
|
||||
double lastResourceLog = 0.0;
|
||||
while (!window.shouldClose()) {
|
||||
window.pollEvents();
|
||||
|
||||
const double loopSeconds =
|
||||
std::chrono::duration<double>(ProfileClock::now() - loopStart).count();
|
||||
if (quitAfterSeconds > 0.0f && loopSeconds >= quitAfterSeconds) {
|
||||
logInfo("--quit-after : " + std::to_string(quitAfterSeconds) +
|
||||
" s de boucle ecoulees, fermeture.");
|
||||
break;
|
||||
}
|
||||
if (loopSeconds - lastResourceLog >= 10.0) {
|
||||
lastResourceLog = loopSeconds;
|
||||
logInfo("Ressources (PHASE 30) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ".");
|
||||
}
|
||||
|
||||
const double now = glfwGetTime();
|
||||
const float deltaTime = static_cast<float>(now - lastTime);
|
||||
lastTime = now;
|
||||
@@ -2301,6 +2356,9 @@ int main(int argc, char** argv) {
|
||||
// demarrage, donc la valeur reste petite et n'use pas la precision
|
||||
// d'un float, contrairement a une horloge absolue.
|
||||
const float elapsedSeconds = static_cast<float>(now);
|
||||
// PHASE 30 : horloge des SHADERS seulement (--freeze-anim). La
|
||||
// logique de jeu garde elapsedSeconds.
|
||||
const float animationSeconds = freezeAnimation ? 0.0f : elapsedSeconds;
|
||||
|
||||
// --- Bascule du MODE EDITEUR (PHASE 15) ------------------------
|
||||
// Traitee AVANT camera.update : entrer en edition change le mode et
|
||||
@@ -3682,7 +3740,7 @@ int main(int argc, char** argv) {
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
// Amplitude d'ondulation NULLE : un tronc ne plie pas.
|
||||
item.params = { 0.0f, elapsedSeconds, 0.0f, 0.0f };
|
||||
item.params = { 0.0f, animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushTrees(treeInstances, sceneryTreeMeshHandle);
|
||||
@@ -3703,7 +3761,7 @@ int main(int argc, char** argv) {
|
||||
// seul materiau qui s'en sert : un arbre pousse 0 et
|
||||
// traverse le meme pipeline, inchange.
|
||||
item.params = { vegetation->params().grassSway,
|
||||
elapsedSeconds, 0.0f,
|
||||
animationSeconds, 0.0f,
|
||||
vegetation->params().grassCutout };
|
||||
instancedItems.push_back(item);
|
||||
}
|
||||
@@ -3734,7 +3792,7 @@ int main(int argc, char** argv) {
|
||||
// pas par un masque - ces plantes sont peu nombreuses,
|
||||
// le budget de sommets n'est pas le sujet.
|
||||
item.params = { 0.35f * vegetation->params().grassSway,
|
||||
elapsedSeconds, 0.0f, 0.0f };
|
||||
animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
}
|
||||
}
|
||||
@@ -3760,7 +3818,7 @@ int main(int argc, char** argv) {
|
||||
item.instances = instances.data();
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
item.params = { 0.0f, elapsedSeconds, 0.0f, -1.0f };
|
||||
item.params = { 0.0f, animationSeconds, 0.0f, -1.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushRocks(boulderInstances, boulderMeshHandle);
|
||||
@@ -3786,7 +3844,7 @@ int main(int argc, char** argv) {
|
||||
item.instances = instances.data();
|
||||
item.count = static_cast<uint32_t>(instances.size());
|
||||
item.material = Material::Foliage;
|
||||
item.params = { sway, elapsedSeconds, 0.0f, 0.0f };
|
||||
item.params = { sway, animationSeconds, 0.0f, 0.0f };
|
||||
instancedItems.push_back(item);
|
||||
};
|
||||
pushBushes(shrubInstances, shrubMeshHandle, 0.04f);
|
||||
@@ -3846,7 +3904,7 @@ int main(int argc, char** argv) {
|
||||
renderer.setWeatherVisuals(visuals.fogColor, visuals.fogDensityPerMeter,
|
||||
visuals.precipitation, visuals.snow,
|
||||
visuals.fallVelocity, visuals.groundDarkening,
|
||||
elapsedSeconds);
|
||||
animationSeconds);
|
||||
frameProfile.weatherVisualsMicros += profileMicros(tw0, ProfileClock::now());
|
||||
|
||||
// Journal BORNE PAR LE TEMPS (lecon de la Phase 24 : "sur
|
||||
@@ -3918,6 +3976,12 @@ int main(int argc, char** argv) {
|
||||
// S'assurer que le GPU a fini avant de detruire quoi que ce soit.
|
||||
renderer.waitIdle();
|
||||
|
||||
// PHASE 30 : bilan des ressources, AVANT toute destruction - les chiffres
|
||||
// "vivants" sont donc ceux du jeu en regime etabli, les pics ceux de la
|
||||
// session entiere.
|
||||
logInfo("Ressources en fin de partie (PHASE 30) : " + processMemoryLine() + ", " +
|
||||
context.gpuMemoryLine() + ".");
|
||||
|
||||
if (frameProfile.frames > 0) {
|
||||
const auto per = [&](uint64_t total) {
|
||||
const double value = static_cast<double>(total) /
|
||||
|
||||
@@ -66,10 +66,7 @@ void SwapChain::cleanupSizeDependent() {
|
||||
vkDestroyImage(device, depthImage_, nullptr);
|
||||
depthImage_ = VK_NULL_HANDLE;
|
||||
}
|
||||
if (depthImageMemory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, depthImageMemory_, nullptr);
|
||||
depthImageMemory_ = VK_NULL_HANDLE;
|
||||
}
|
||||
context_.freeMemory(depthAllocation_);
|
||||
|
||||
for (VkFramebuffer fb : framebuffers_) {
|
||||
vkDestroyFramebuffer(device, fb, nullptr);
|
||||
@@ -342,16 +339,10 @@ void SwapChain::createDepthResources() {
|
||||
VkMemoryRequirements memRequirements{};
|
||||
vkGetImageMemoryRequirements(device, depthImage_, &memRequirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = memRequirements.size;
|
||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
||||
memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &depthImageMemory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation memoire de profondeur.");
|
||||
}
|
||||
vkBindImageMemory(device, depthImage_, depthImageMemory_, 0);
|
||||
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
depthAllocation_ = context_.allocateMemory(memRequirements,
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
vkBindImageMemory(device, depthImage_, depthAllocation_.memory, 0);
|
||||
|
||||
VkImageViewCreateInfo viewInfo{};
|
||||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <vector>
|
||||
@@ -68,7 +70,7 @@ private:
|
||||
// par le render pass). Recree en meme temps que la swapchain au resize.
|
||||
VkFormat depthFormat_ = VK_FORMAT_UNDEFINED;
|
||||
VkImage depthImage_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory depthImageMemory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation depthAllocation_;
|
||||
VkImageView depthImageView_ = VK_NULL_HANDLE;
|
||||
|
||||
VkRenderPass renderPass_ = VK_NULL_HANDLE;
|
||||
|
||||
@@ -176,7 +176,11 @@ public:
|
||||
// Ni la Heightmap ni le Renderer ne sont possedes ; les deux doivent vivre
|
||||
// plus longtemps que le streamer.
|
||||
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer,
|
||||
const Params& params = {});
|
||||
const Params& params);
|
||||
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
|
||||
// de GCC/Clang, CWG 1397).
|
||||
TerrainStreamer(const Heightmap& heightmap, Renderer& renderer)
|
||||
: TerrainStreamer(heightmap, renderer, Params{}) {}
|
||||
~TerrainStreamer();
|
||||
|
||||
TerrainStreamer(const TerrainStreamer&) = delete;
|
||||
|
||||
@@ -111,9 +111,7 @@ Texture::~Texture() {
|
||||
if (image_ != VK_NULL_HANDLE) {
|
||||
vkDestroyImage(device, image_, nullptr);
|
||||
}
|
||||
if (memory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, memory_, nullptr);
|
||||
}
|
||||
context_.freeMemory(allocation_);
|
||||
}
|
||||
|
||||
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
@@ -139,16 +137,9 @@ void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
VkMemoryRequirements requirements{};
|
||||
vkGetImageMemoryRequirements(device, image_, &requirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = requirements.size;
|
||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
||||
requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de l'allocation memoire de l'image.");
|
||||
}
|
||||
vkBindImageMemory(device, image_, memory_, 0);
|
||||
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
allocation_ = context_.allocateMemory(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
vkBindImageMemory(device, image_, allocation_.memory, 0);
|
||||
deviceSize_ = requirements.size;
|
||||
}
|
||||
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
// le renvoie par valeur. L'en-tete reste sans cout : assets/TextureFile.hpp ne
|
||||
// depend pas de Vulkan.
|
||||
#include "assets/TextureFile.hpp"
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
@@ -74,7 +75,7 @@ private:
|
||||
|
||||
VulkanContext& context_;
|
||||
VkImage image_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation allocation_;
|
||||
VkImageView view_ = VK_NULL_HANDLE;
|
||||
VkSampler sampler_ = VK_NULL_HANDLE;
|
||||
VkDeviceSize deviceSize_ = 0;
|
||||
|
||||
@@ -27,42 +27,38 @@ VulkanBuffer::VulkanBuffer(VulkanContext& context,
|
||||
VkMemoryRequirements memRequirements{};
|
||||
vkGetBufferMemoryRequirements(device, buffer_, &memRequirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = memRequirements.size;
|
||||
allocInfo.memoryTypeIndex =
|
||||
context_.findMemoryType(memRequirements.memoryTypeBits, properties);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation memoire d'un buffer.");
|
||||
// PHASE 30 : par le contexte, qui tient le compte de la memoire GPU.
|
||||
try {
|
||||
allocation_ = context_.allocateMemory(memRequirements, properties);
|
||||
} catch (...) {
|
||||
vkDestroyBuffer(device, buffer_, nullptr);
|
||||
throw;
|
||||
}
|
||||
|
||||
vkBindBufferMemory(device, buffer_, memory_, 0);
|
||||
vkBindBufferMemory(device, buffer_, allocation_.memory, 0);
|
||||
}
|
||||
|
||||
VulkanBuffer::~VulkanBuffer() {
|
||||
VkDevice device = context_.device();
|
||||
if (mapped_ != nullptr) {
|
||||
vkUnmapMemory(device, memory_);
|
||||
vkUnmapMemory(device, allocation_.memory);
|
||||
mapped_ = nullptr;
|
||||
}
|
||||
if (buffer_ != VK_NULL_HANDLE) {
|
||||
vkDestroyBuffer(device, buffer_, nullptr);
|
||||
}
|
||||
if (memory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, memory_, nullptr);
|
||||
}
|
||||
context_.freeMemory(allocation_);
|
||||
}
|
||||
|
||||
void VulkanBuffer::map() {
|
||||
if (mapped_ == nullptr) {
|
||||
vkMapMemory(context_.device(), memory_, 0, size_, 0, &mapped_);
|
||||
vkMapMemory(context_.device(), allocation_.memory, 0, size_, 0, &mapped_);
|
||||
}
|
||||
}
|
||||
|
||||
void VulkanBuffer::unmap() {
|
||||
if (mapped_ != nullptr) {
|
||||
vkUnmapMemory(context_.device(), memory_);
|
||||
vkUnmapMemory(context_.device(), allocation_.memory);
|
||||
mapped_ = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "renderer/VulkanContext.hpp" // GpuAllocation
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <memory>
|
||||
@@ -76,7 +78,7 @@ private:
|
||||
VulkanContext& context_;
|
||||
VkDeviceSize size_ = 0;
|
||||
VkBuffer buffer_ = VK_NULL_HANDLE;
|
||||
VkDeviceMemory memory_ = VK_NULL_HANDLE;
|
||||
GpuAllocation allocation_;
|
||||
void* mapped_ = nullptr;
|
||||
};
|
||||
|
||||
|
||||
@@ -3,6 +3,8 @@
|
||||
#include "core/Logger.hpp"
|
||||
#include "core/Window.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <set>
|
||||
#include <stdexcept>
|
||||
@@ -233,6 +235,28 @@ void VulkanContext::pickPhysicalDevice() {
|
||||
VkPhysicalDeviceProperties props{};
|
||||
vkGetPhysicalDeviceProperties(physicalDevice_, &props);
|
||||
logInfo(std::string("GPU selectionne : ") + props.deviceName);
|
||||
|
||||
// PHASE 30 : proprietes memoire lues UNE fois (voir findMemoryType), et
|
||||
// detection de la memoire unifiee.
|
||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memoryProperties_);
|
||||
const VkMemoryPropertyFlags unified = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
|
||||
std::string heaps = "Memoire GPU : " + std::to_string(memoryProperties_.memoryHeapCount) +
|
||||
" tas -";
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryHeapCount; ++i) {
|
||||
const VkMemoryHeap& heap = memoryProperties_.memoryHeaps[i];
|
||||
heaps += " [" + std::to_string(i) + "] " +
|
||||
std::to_string(heap.size / (1024 * 1024)) + " Mo" +
|
||||
((heap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) ? " device-local" : "");
|
||||
}
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
|
||||
if ((memoryProperties_.memoryTypes[i].propertyFlags & unified) == unified) {
|
||||
unifiedMemory_ = true;
|
||||
}
|
||||
}
|
||||
logInfo(heaps + (unifiedMemory_ ? " ; memoire UNIFIEE (device-local et host-visible)."
|
||||
: " ; memoire device-local NON mappable."));
|
||||
}
|
||||
|
||||
bool VulkanContext::isDeviceSuitable(VkPhysicalDevice device) const {
|
||||
@@ -397,13 +421,10 @@ SwapChainSupportDetails VulkanContext::querySwapChainSupport() const {
|
||||
}
|
||||
|
||||
uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const {
|
||||
VkPhysicalDeviceMemoryProperties memProperties{};
|
||||
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memProperties);
|
||||
|
||||
for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
|
||||
for (uint32_t i = 0; i < memoryProperties_.memoryTypeCount; ++i) {
|
||||
const bool typeOk = (typeFilter & (1u << i)) != 0;
|
||||
const bool propsOk =
|
||||
(memProperties.memoryTypes[i].propertyFlags & properties) == properties;
|
||||
(memoryProperties_.memoryTypes[i].propertyFlags & properties) == properties;
|
||||
if (typeOk && propsOk) {
|
||||
return i;
|
||||
}
|
||||
@@ -411,6 +432,70 @@ uint32_t VulkanContext::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlag
|
||||
throw std::runtime_error("Aucun type de memoire adapte trouve.");
|
||||
}
|
||||
|
||||
GpuAllocation VulkanContext::allocateMemory(const VkMemoryRequirements& requirements,
|
||||
VkMemoryPropertyFlags properties, bool map) {
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = requirements.size;
|
||||
allocInfo.memoryTypeIndex = findMemoryType(requirements.memoryTypeBits, properties);
|
||||
|
||||
GpuAllocation allocation;
|
||||
if (vkAllocateMemory(device_, &allocInfo, nullptr, &allocation.memory) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Echec de l'allocation de " +
|
||||
std::to_string(requirements.size) +
|
||||
" octets de memoire GPU.");
|
||||
}
|
||||
allocation.size = requirements.size;
|
||||
allocation.deviceLocal = (properties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0;
|
||||
if (map && vkMapMemory(device_, allocation.memory, 0, VK_WHOLE_SIZE, 0,
|
||||
&allocation.mapped) != VK_SUCCESS) {
|
||||
vkFreeMemory(device_, allocation.memory, nullptr);
|
||||
throw std::runtime_error("Echec du mappage d'un bloc de memoire GPU.");
|
||||
}
|
||||
|
||||
gpuMemory_.liveBytes += allocation.size;
|
||||
gpuMemory_.peakBytes = std::max(gpuMemory_.peakBytes, gpuMemory_.liveBytes);
|
||||
if (allocation.deviceLocal) {
|
||||
gpuMemory_.liveDeviceLocalBytes += allocation.size;
|
||||
gpuMemory_.peakDeviceLocalBytes =
|
||||
std::max(gpuMemory_.peakDeviceLocalBytes, gpuMemory_.liveDeviceLocalBytes);
|
||||
}
|
||||
++gpuMemory_.liveAllocations;
|
||||
gpuMemory_.peakAllocations = std::max(gpuMemory_.peakAllocations, gpuMemory_.liveAllocations);
|
||||
++gpuMemory_.allocateCalls;
|
||||
return allocation;
|
||||
}
|
||||
|
||||
void VulkanContext::freeMemory(GpuAllocation& allocation) {
|
||||
if (allocation.memory == VK_NULL_HANDLE) {
|
||||
return;
|
||||
}
|
||||
if (allocation.mapped != nullptr) {
|
||||
vkUnmapMemory(device_, allocation.memory);
|
||||
}
|
||||
vkFreeMemory(device_, allocation.memory, nullptr);
|
||||
gpuMemory_.liveBytes -= allocation.size;
|
||||
if (allocation.deviceLocal) {
|
||||
gpuMemory_.liveDeviceLocalBytes -= allocation.size;
|
||||
}
|
||||
--gpuMemory_.liveAllocations;
|
||||
allocation = GpuAllocation{};
|
||||
}
|
||||
|
||||
std::string VulkanContext::gpuMemoryLine() const {
|
||||
const auto mo = [](uint64_t bytes) {
|
||||
char text[32];
|
||||
std::snprintf(text, sizeof(text), "%.1f Mo", static_cast<double>(bytes) / (1024.0 * 1024.0));
|
||||
return std::string(text);
|
||||
};
|
||||
return "GPU " + mo(gpuMemory_.liveBytes) + " (pic " + mo(gpuMemory_.peakBytes) +
|
||||
"), dont device-local " + mo(gpuMemory_.liveDeviceLocalBytes) + " (pic " +
|
||||
mo(gpuMemory_.peakDeviceLocalBytes) + ") ; " +
|
||||
std::to_string(gpuMemory_.liveAllocations) + " blocs vivants (pic " +
|
||||
std::to_string(gpuMemory_.peakAllocations) + "), " +
|
||||
std::to_string(gpuMemory_.allocateCalls) + " vkAllocateMemory au total";
|
||||
}
|
||||
|
||||
VkFormat VulkanContext::findSupportedFormat(const std::vector<VkFormat>& candidates,
|
||||
VkImageTiling tiling,
|
||||
VkFormatFeatureFlags features) const {
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace vercora {
|
||||
@@ -41,6 +42,32 @@ struct SwapChainSupportDetails {
|
||||
std::vector<VkPresentModeKHR> presentModes;
|
||||
};
|
||||
|
||||
// PHASE 30. Un bloc de memoire GPU, avec ce qu'il faut savoir pour le rendre
|
||||
// et pour le COMPTER. Toute la memoire du moteur passe par
|
||||
// VulkanContext::allocateMemory / freeMemory : c'est ce qui permet au journal
|
||||
// de donner l'occupation GPU exacte, au lieu de la deduire de formules
|
||||
// recopiees dans chaque classe (et dont une seule serait mise a jour).
|
||||
struct GpuAllocation {
|
||||
VkDeviceMemory memory = VK_NULL_HANDLE;
|
||||
VkDeviceSize size = 0; // octets REELLEMENT alloues (memory requirements)
|
||||
bool deviceLocal = false; // DEVICE_LOCAL demande par l'appelant
|
||||
void* mapped = nullptr; // mappage persistant, si demande
|
||||
};
|
||||
|
||||
// PHASE 30. Bilan de la memoire GPU allouee par le moteur. Les pics sont ceux
|
||||
// de la session ; "appels" compte tous les vkAllocateMemory depuis le
|
||||
// demarrage, y compris ceux deja liberes - c'est le chiffre qui dit combien de
|
||||
// fois le pilote a ete sollicite, pas seulement combien de blocs vivent.
|
||||
struct GpuMemoryStats {
|
||||
uint64_t liveBytes = 0;
|
||||
uint64_t peakBytes = 0;
|
||||
uint64_t liveDeviceLocalBytes = 0;
|
||||
uint64_t peakDeviceLocalBytes = 0;
|
||||
uint64_t liveAllocations = 0;
|
||||
uint64_t peakAllocations = 0;
|
||||
uint64_t allocateCalls = 0;
|
||||
};
|
||||
|
||||
// Regroupe l'etat "global" Vulkan qui ne change pas au resize :
|
||||
// instance, debug messenger, surface, GPU physique, device logique, queues.
|
||||
class VulkanContext {
|
||||
@@ -84,6 +111,28 @@ public:
|
||||
// Format de profondeur retenu (D32 de preference, avec fallbacks).
|
||||
VkFormat findDepthFormat() const;
|
||||
|
||||
// PHASE 30. Alloue un bloc satisfaisant `requirements` dans un type de
|
||||
// memoire qui porte `properties`, et le COMPTE. Lance std::runtime_error si
|
||||
// le pilote refuse. `map` = true mappe le bloc en permanence (le type doit
|
||||
// alors etre HOST_VISIBLE).
|
||||
GpuAllocation allocateMemory(const VkMemoryRequirements& requirements,
|
||||
VkMemoryPropertyFlags properties, bool map = false);
|
||||
|
||||
// Rend le bloc (demappe s'il l'etait) et le decompte. Sans effet sur une
|
||||
// allocation vide ; remet `allocation` a zero.
|
||||
void freeMemory(GpuAllocation& allocation);
|
||||
|
||||
const GpuMemoryStats& gpuMemoryStats() const { return gpuMemory_; }
|
||||
|
||||
// Ligne de journal lisible du bilan ci-dessus.
|
||||
std::string gpuMemoryLine() const;
|
||||
|
||||
// PHASE 30. true si un type de memoire est a la fois DEVICE_LOCAL et
|
||||
// HOST_VISIBLE | HOST_COHERENT : memoire unifiee (GPU integre, lavapipe), ou
|
||||
// le CPU peut ecrire directement la ou le GPU lit, sans staging ni copie.
|
||||
// Faux sur un GPU discret classique (hors BAR redimensionnable).
|
||||
bool unifiedMemory() const { return unifiedMemory_; }
|
||||
|
||||
private:
|
||||
void createInstance();
|
||||
void setupDebugMessenger();
|
||||
@@ -110,6 +159,13 @@ private:
|
||||
QueueFamilyIndices queueIndices_;
|
||||
|
||||
bool anisotropyEnabled_ = false;
|
||||
bool unifiedMemory_ = false;
|
||||
|
||||
// Proprietes memoire du GPU, lues une fois : findMemoryType les
|
||||
// interrogeait a CHAQUE allocation (deux par tuile de terrain).
|
||||
VkPhysicalDeviceMemoryProperties memoryProperties_{};
|
||||
|
||||
GpuMemoryStats gpuMemory_;
|
||||
};
|
||||
|
||||
} // namespace vercora
|
||||
@@ -127,7 +127,10 @@ public:
|
||||
// pour le rendu que pour la COLLISION (voir la note de decouplage dans
|
||||
// MEMORY.md). L'arbre n'en garde que des bornes.
|
||||
// Lance std::runtime_error si les parametres sont inexploitables.
|
||||
TerrainQuadtree(const Heightmap& heightmap, const Params& params = {});
|
||||
TerrainQuadtree(const Heightmap& heightmap, const Params& params);
|
||||
// Parametres par defaut : surcharge et non `= {}`, voir Heightmap() (refus
|
||||
// de GCC/Clang, CWG 1397).
|
||||
TerrainQuadtree(const Heightmap& heightmap) : TerrainQuadtree(heightmap, Params{}) {}
|
||||
|
||||
// Remplit `out` avec les noeuds a dessiner, tries du plus proche au plus
|
||||
// lointain. `out` est vide au prealable ; sa capacite est conservee.
|
||||
|
||||
@@ -0,0 +1,249 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
make_bench_zone.py — fabrique une zone PROXY de 25 km2 pour MESURER le moteur
|
||||
sur une machine qui n'a pas les donnees LiDAR (session cloud, CI, nouveau poste).
|
||||
|
||||
PHASE 30. Les dalles LiDAR (data/lidar, plusieurs Go) et les .vchm qui en sont
|
||||
tires ne sont pas versionnes ; seule l'orthophoto vercora_zone_ortho.vcto l'est.
|
||||
Sans terrain de zone, le jeu retombe sur le terrain synthetique 128x128 : un
|
||||
banc de mesure n'y exerce ni le streaming de 8 000 noeuds, ni la vegetation a
|
||||
l'echelle, ni rien de ce qui pese reellement en memoire.
|
||||
|
||||
Ce script ecrit, dans assets/terrain/ (ignore par git, *.vchm) :
|
||||
vercora_zone_1m.vchm 5001 x 5001 au pas de 1 m
|
||||
vercora_zone_canopy.vchm couvert 0..1, 1001 x 1001 au pas de 5 m
|
||||
vercora_zone_canopy_height.vchm hauteur de canopee (m)
|
||||
vercora_zone_canopy_lowveg.vchm fraction de vegetation basse (F3)
|
||||
vercora_zone_canopy_lowveg_height.vchm hauteur de vegetation basse (m)
|
||||
|
||||
CE QUI EST VRAI ET CE QUI NE L'EST PAS, sans detour :
|
||||
- L'EMPRISE, la RESOLUTION, la georeference et la plage d'altitudes
|
||||
(1029-2285 m) sont celles de la vraie zone : le quadtree, le streaming,
|
||||
l'orthophoto (qui s'y applique, orthoMatchesTerrain passe) et tous les
|
||||
budgets memoire travaillent donc a la vraie echelle.
|
||||
- Le RELIEF est un bruit fractal (fBm + cretes, la recette de
|
||||
Heightmap::Params), pas le Vercors.
|
||||
- Le COUVERT est tire de la VRAIE orthophoto (indice de vert sur le niveau de
|
||||
mipmap 2048 x 2048) : les arbres poussent la ou la photo montre de la foret,
|
||||
mais sur un relief qui n'est pas le sien.
|
||||
Les chiffres de MEMOIRE et de COUT obtenus sur cette zone sont donc
|
||||
representatifs a l'ordre de grandeur et comparables ENTRE EUX (avant / apres
|
||||
une optimisation) ; ils ne remplacent pas une mesure sur les vraies donnees.
|
||||
|
||||
python tools/make_bench_zone.py # ecrit dans assets/terrain/
|
||||
python tools/make_bench_zone.py --force # ecrase des fichiers existants
|
||||
|
||||
Refuse d'ecraser un fichier existant sans --force : sur la machine de
|
||||
developpement, ces noms sont ceux des VRAIES donnees.
|
||||
|
||||
Dependances : numpy.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
import numpy as np
|
||||
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
TERRAIN_DIR = os.path.join(ROOT, "assets", "terrain")
|
||||
ORTHO = os.path.join(TERRAIN_DIR, "vercora_zone_ortho.vcto")
|
||||
|
||||
# Emprise de la vraie zone (en-tete de vercora_zone_ortho.vcto).
|
||||
ORIGIN_EAST = 899000.0
|
||||
ORIGIN_NORTH = 6440000.0
|
||||
EXTENT_M = 5000.0
|
||||
EPSG = 2154
|
||||
ALT_MIN = 1029.0
|
||||
ALT_MAX = 2285.0
|
||||
SEED = 20261013
|
||||
|
||||
|
||||
def write_vchm(path: str, grid: np.ndarray, spacing: float, label: str,
|
||||
absolute: bool) -> None:
|
||||
"""Ecrit un .vchm version 1 (format : src/assets/TerrainFile.hpp)."""
|
||||
grid = np.ascontiguousarray(grid, dtype="<f4")
|
||||
n = grid.shape[0]
|
||||
assert grid.shape == (n, n)
|
||||
header = bytearray(120)
|
||||
header[0:4] = b"VCHM"
|
||||
struct.pack_into("<IIIf", header, 4, 1, n, n, spacing)
|
||||
struct.pack_into("<dd", header, 24, ORIGIN_EAST, ORIGIN_NORTH)
|
||||
struct.pack_into("<ffII", header, 40, float(grid.min()), float(grid.max()),
|
||||
EPSG, 1 if absolute else 0)
|
||||
raw = label.encode("ascii")[:64]
|
||||
header[56:56 + len(raw)] = raw
|
||||
with open(path, "wb") as f:
|
||||
f.write(header)
|
||||
f.write(grid.tobytes())
|
||||
|
||||
|
||||
def smooth(t: np.ndarray) -> np.ndarray:
|
||||
return t * t * (3.0 - 2.0 * t)
|
||||
|
||||
|
||||
def value_noise(n: int, cells: int, rng: np.random.Generator) -> np.ndarray:
|
||||
"""Bruit de valeur n x n a `cells` cellules par cote, interpolation
|
||||
separable (d'abord le long de X pour chaque ligne du reseau, puis le long
|
||||
de Z) : 3 operations par echantillon au lieu de 4 lectures + 3 lerps."""
|
||||
lattice = rng.random((cells + 2, cells + 2), dtype=np.float32)
|
||||
x = np.linspace(0.0, cells, n, dtype=np.float64)
|
||||
i0 = np.minimum(np.floor(x).astype(np.int64), cells)
|
||||
t = smooth((x - i0).astype(np.float32))
|
||||
along_x = lattice[:, i0] * (1.0 - t) + lattice[:, i0 + 1] * t # (cells+2, n)
|
||||
return along_x[i0, :] * (1.0 - t)[:, None] + along_x[i0 + 1, :] * t[:, None]
|
||||
|
||||
|
||||
def fbm(n: int, base: int, octaves: int, ridged: bool, rng) -> np.ndarray:
|
||||
total = np.zeros((n, n), dtype=np.float32)
|
||||
norm = 0.0
|
||||
amplitude = 1.0
|
||||
cells = base
|
||||
for _ in range(octaves):
|
||||
octave = value_noise(n, cells, rng)
|
||||
if ridged:
|
||||
octave = 1.0 - np.abs(2.0 * octave - 1.0)
|
||||
total += amplitude * octave
|
||||
norm += amplitude
|
||||
amplitude *= 0.5
|
||||
cells *= 2
|
||||
return total / norm
|
||||
|
||||
|
||||
def make_relief(n: int) -> np.ndarray:
|
||||
rng = np.random.default_rng(SEED)
|
||||
soft = fbm(n, 3, 9, False, rng) ** 1.4
|
||||
ridge = fbm(n, 3, 9, True, rng)
|
||||
shaped = soft + (ridge * ridge - soft) * 0.6
|
||||
# Barres rocheuses facon Vercors : une marche raide la ou un bruit tres
|
||||
# large franchit un seuil. Sans elles le relief n'offrirait aucune paroi
|
||||
# d'escalade (pente >= 0,84) ni de pierrier (0,60-0,84).
|
||||
band = value_noise(n, 4, rng)
|
||||
cliff = smooth(np.clip((band - 0.55) / 0.02, 0.0, 1.0))
|
||||
shaped = shaped + 0.12 * cliff
|
||||
lo, hi = float(shaped.min()), float(shaped.max())
|
||||
return (ALT_MIN + (shaped - lo) / (hi - lo) * (ALT_MAX - ALT_MIN)).astype(np.float32)
|
||||
|
||||
|
||||
def decode_bc1_level(path: str, level: int) -> np.ndarray:
|
||||
"""Decode le niveau `level` d'un .vcto BC1 en RGB float [0,1]."""
|
||||
with open(path, "rb") as f:
|
||||
data = f.read()
|
||||
if data[:4] != b"VCTO":
|
||||
raise SystemExit(f"{path} n'est pas un .vcto")
|
||||
width, height, mips, fmt = struct.unpack_from("<IIII", data, 8)
|
||||
if fmt != 1:
|
||||
raise SystemExit("orthophoto attendue en BC1")
|
||||
offset = 128
|
||||
for k in range(level):
|
||||
w, h = max(1, width >> k), max(1, height >> k)
|
||||
offset += ((w + 3) // 4) * ((h + 3) // 4) * 8
|
||||
w, h = max(1, width >> level), max(1, height >> level)
|
||||
bx, by = (w + 3) // 4, (h + 3) // 4
|
||||
blocks = np.frombuffer(data, dtype="<u2", count=bx * by * 4, offset=offset)
|
||||
blocks = blocks.reshape(by, bx, 4)
|
||||
c0 = blocks[..., 0].astype(np.uint32)
|
||||
c1 = blocks[..., 1].astype(np.uint32)
|
||||
bits = blocks[..., 2].astype(np.uint32) | (blocks[..., 3].astype(np.uint32) << 16)
|
||||
|
||||
def rgb565(c):
|
||||
r = ((c >> 11) & 31) / 31.0
|
||||
g = ((c >> 5) & 63) / 63.0
|
||||
b = (c & 31) / 31.0
|
||||
return np.stack([r, g, b], axis=-1)
|
||||
|
||||
p0, p1 = rgb565(c0), rgb565(c1)
|
||||
four = (c0 > c1)[..., None]
|
||||
p2 = np.where(four, (2 * p0 + p1) / 3, (p0 + p1) / 2)
|
||||
p3 = np.where(four, (p0 + 2 * p1) / 3, 0.0)
|
||||
palette = np.stack([p0, p1, p2, p3], axis=2) # (by, bx, 4, 3)
|
||||
out = np.zeros((by * 4, bx * 4, 3), dtype=np.float32)
|
||||
for py in range(4):
|
||||
for px in range(4):
|
||||
idx = (bits >> (2 * (py * 4 + px))) & 3
|
||||
texel = np.take_along_axis(palette, idx[..., None, None].repeat(3, -1),
|
||||
axis=2)[:, :, 0, :]
|
||||
out[py::4, px::4, :] = texel
|
||||
return out[:h, :w]
|
||||
|
||||
|
||||
def resample(image: np.ndarray, n: int) -> np.ndarray:
|
||||
"""Echantillonne l'image (rangee du nord au sud) aux n x n points de grille
|
||||
(coins compris), par moyenne d'une fenetre 3 x 3 autour du texel."""
|
||||
h, w = image.shape[:2]
|
||||
coords = np.linspace(0.0, 1.0, n)
|
||||
ys = np.clip(np.round(coords * (h - 1)).astype(np.int64), 1, h - 2)
|
||||
xs = np.clip(np.round(coords * (w - 1)).astype(np.int64), 1, w - 2)
|
||||
acc = np.zeros((n, n) + image.shape[2:], dtype=np.float32)
|
||||
for dy in (-1, 0, 1):
|
||||
for dx in (-1, 0, 1):
|
||||
acc += image[(ys + dy)[:, None], (xs + dx)[None, :]]
|
||||
return acc / 9.0
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[1])
|
||||
parser.add_argument("--force", action="store_true",
|
||||
help="ecraser des fichiers existants")
|
||||
args = parser.parse_args()
|
||||
|
||||
names = {
|
||||
"terrain": "vercora_zone_1m.vchm",
|
||||
"cover": "vercora_zone_canopy.vchm",
|
||||
"height": "vercora_zone_canopy_height.vchm",
|
||||
"lowveg": "vercora_zone_canopy_lowveg.vchm",
|
||||
"lowveg_height": "vercora_zone_canopy_lowveg_height.vchm",
|
||||
}
|
||||
paths = {k: os.path.join(TERRAIN_DIR, v) for k, v in names.items()}
|
||||
existing = [p for p in paths.values() if os.path.exists(p)]
|
||||
if existing and not args.force:
|
||||
print("Refus : ces fichiers existent deja (vraies donnees ?) :")
|
||||
for p in existing:
|
||||
print(" " + p)
|
||||
print("Relancer avec --force pour les ecraser.")
|
||||
return 1
|
||||
if not os.path.exists(ORTHO):
|
||||
print(f"Orthophoto introuvable : {ORTHO}")
|
||||
return 1
|
||||
|
||||
t0 = time.time()
|
||||
relief = make_relief(5001)
|
||||
write_vchm(paths["terrain"], relief, 1.0, "vercora_zone PROXY bench (relief fBm)", True)
|
||||
print(f"terrain : {paths['terrain']} ({relief.min():.1f} .. {relief.max():.1f} m, "
|
||||
f"{time.time() - t0:.1f} s)")
|
||||
|
||||
rgb = decode_bc1_level(ORTHO, 2) # 2048 x 2048, 2,44 m/texel
|
||||
rgb5 = resample(rgb, 1001)
|
||||
r, g, b = rgb5[..., 0], rgb5[..., 1], rgb5[..., 2]
|
||||
lum = (r + g + b) / 3.0
|
||||
exg = 2.0 * g - r - b
|
||||
# Foret = sombre ET verte ; prairie = verte mais claire ; roche = grise.
|
||||
green = np.clip(exg / 0.06, 0.0, 1.0)
|
||||
dark = np.clip((0.45 - lum) / 0.18, 0.0, 1.0)
|
||||
cover = np.clip(green * dark * 1.6, 0.0, 1.0).astype(np.float32)
|
||||
rng = np.random.default_rng(SEED + 1)
|
||||
tall = 14.0 + 16.0 * value_noise(1001, 40, rng)
|
||||
canopy = np.where(cover > 0.15, tall * np.clip(cover * 1.5, 0.3, 1.0), 0.0)
|
||||
shrub = np.clip(green * (1.0 - dark) * 0.35 + cover * (1.0 - cover) * 0.5, 0.0, 0.6)
|
||||
lowveg = shrub.astype(np.float32)
|
||||
lowveg_h = np.where(lowveg > 0.05, 0.6 + 3.6 * value_noise(1001, 60, rng), 0.0)
|
||||
|
||||
write_vchm(paths["cover"], cover, 5.0, "vercora_zone PROXY couvert (ortho)", False)
|
||||
write_vchm(paths["height"], canopy.astype(np.float32), 5.0,
|
||||
"vercora_zone PROXY canopee", False)
|
||||
write_vchm(paths["lowveg"], lowveg, 5.0, "vercora_zone PROXY vegetation basse", False)
|
||||
write_vchm(paths["lowveg_height"], lowveg_h.astype(np.float32), 5.0,
|
||||
"vercora_zone PROXY h vegetation basse", False)
|
||||
print(f"couvert : moyenne {cover.mean():.3f}, cellules > 0,5 : "
|
||||
f"{(cover > 0.5).mean() * 100:.1f} % ; F3 moyenne {lowveg.mean():.3f}")
|
||||
print(f"total {time.time() - t0:.1f} s")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur