Fichiers
vercora/src/renderer/GpuBufferPool.cpp
T
Claude f15fb63b7d 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

179 lignes
6.0 KiB
C++

#include "renderer/GpuBufferPool.hpp"
#include <cstdio>
#include <stdexcept>
namespace vercora {
GpuBufferPool::GpuBufferPool(VulkanContext& context, VkBufferUsageFlags usage,
VkMemoryPropertyFlags properties, bool mapped,
VkDeviceSize blockSize)
: context_(context), usage_(usage), properties_(properties), mapped_(mapped),
blockSize_(blockSize) {
if (mapped_) {
properties_ |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
}
}
GpuBufferPool::~GpuBufferPool() {
for (std::unique_ptr<Block>& block : blocks_) {
if (block) {
destroyBlock(*block);
}
}
}
std::unique_ptr<GpuBufferPool::Block> GpuBufferPool::createBlock(VkDeviceSize capacity,
bool dedicated) {
auto block = std::make_unique<Block>(capacity);
block->dedicated = dedicated;
VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = capacity;
bufferInfo.usage = usage_;
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if (vkCreateBuffer(context_.device(), &bufferInfo, nullptr, &block->buffer) != VK_SUCCESS) {
throw std::runtime_error("GpuBufferPool : echec de la creation d'un bloc de " +
std::to_string(capacity) + " octets.");
}
VkMemoryRequirements requirements{};
vkGetBufferMemoryRequirements(context_.device(), block->buffer, &requirements);
try {
block->memory = context_.allocateMemory(requirements, properties_, mapped_);
} catch (...) {
vkDestroyBuffer(context_.device(), block->buffer, nullptr);
throw;
}
vkBindBufferMemory(context_.device(), block->buffer, block->memory.memory, 0);
capacityBytes_ += capacity;
return block;
}
void GpuBufferPool::destroyBlock(Block& block) {
capacityBytes_ -= block.ranges.capacity();
vkDestroyBuffer(context_.device(), block.buffer, nullptr);
block.buffer = VK_NULL_HANDLE;
context_.freeMemory(block.memory);
}
GpuRange GpuBufferPool::allocate(VkDeviceSize size) {
if (size == 0) {
throw std::runtime_error("GpuBufferPool : allocation de taille nulle.");
}
uint32_t index = UINT32_MAX;
uint64_t offset = RangeAllocator::kInvalid;
if (size > blockSize_ / 2) {
// Bloc DEDIE, a la taille exacte : un tres gros maillage ne doit ni
// gacher un bloc standard, ni l'empecher de servir aux autres.
for (uint32_t k = 0; k <= blocks_.size(); ++k) {
if (k == blocks_.size() || !blocks_[k]) {
index = k;
break;
}
}
auto block = createBlock(size, true);
offset = block->ranges.allocate(size, kAlignment);
if (index == blocks_.size()) {
blocks_.push_back(std::move(block));
} else {
blocks_[index] = std::move(block);
}
} else {
// Premier bloc standard qui a la place.
for (uint32_t k = 0; k < blocks_.size(); ++k) {
Block* block = blocks_[k].get();
if (block == nullptr || block->dedicated) {
continue;
}
offset = block->ranges.allocate(size, kAlignment);
if (offset != RangeAllocator::kInvalid) {
index = k;
break;
}
}
if (offset == RangeAllocator::kInvalid) {
for (uint32_t k = 0; k <= blocks_.size(); ++k) {
if (k == blocks_.size() || !blocks_[k]) {
index = k;
break;
}
}
auto block = createBlock(blockSize_, false);
offset = block->ranges.allocate(size, kAlignment);
if (index == blocks_.size()) {
blocks_.push_back(std::move(block));
} else {
blocks_[index] = std::move(block);
}
}
}
Block& block = *blocks_[index];
GpuRange range;
range.buffer = block.buffer;
range.offset = offset;
range.size = size;
range.block = index;
if (block.memory.mapped != nullptr) {
range.mapped = static_cast<unsigned char*>(block.memory.mapped) + offset;
}
usedBytes_ += size;
return range;
}
void GpuBufferPool::release(const GpuRange& range) {
if (!range.valid() || range.block >= blocks_.size() || !blocks_[range.block]) {
return;
}
Block& block = *blocks_[range.block];
block.ranges.release(range.offset, range.size);
usedBytes_ -= range.size;
if (!block.ranges.empty()) {
return;
}
// Bloc vide. Un bloc dedie part toujours ; un bloc standard part seulement
// s'il existe deja un AUTRE bloc standard vide - en survol, les tuiles
// evincees et construites se croisent sans cesse, et rendre puis
// reallouer 4 Mo a chaque passage a vide ramenerait les allocations que ce
// pool supprime.
bool keep = !block.dedicated;
if (keep) {
for (uint32_t k = 0; k < blocks_.size(); ++k) {
if (k != range.block && blocks_[k] && !blocks_[k]->dedicated &&
blocks_[k]->ranges.empty()) {
keep = false;
break;
}
}
}
if (!keep) {
destroyBlock(block);
blocks_[range.block].reset();
}
}
uint32_t GpuBufferPool::blockCount() const {
uint32_t count = 0;
for (const std::unique_ptr<Block>& block : blocks_) {
count += block ? 1u : 0u;
}
return count;
}
std::string GpuBufferPool::statsLine() const {
char text[160];
std::snprintf(text, sizeof(text),
"%.1f Mo utilises sur %.1f Mo alloues en %u bloc(s), %s",
static_cast<double>(usedBytes_) / (1024.0 * 1024.0),
static_cast<double>(capacityBytes_) / (1024.0 * 1024.0), blockCount(),
mapped_ ? "ecriture directe (memoire unifiee)" : "televersement par staging");
return text;
}
} // namespace vercora