addressing more comments.

Author: gpx1000

attachments/simple_engine/engine.h

@@ -261,7 +261,7 @@ class Engine {
 
     PhysicsScaling physicsScaling;
 
-    // Pending ball creation data (to avoid memory pool constraints during rendering)
+    // Pending ball creation data
     struct PendingBall {
         glm::vec3 spawnPosition;
         glm::vec3 throwDirection;

attachments/simple_engine/memory_pool.cpp

@@ -23,17 +23,15 @@ bool MemoryPool::initialize() {
             PoolType::VERTEX_BUFFER,
             128 * 1024 * 1024, // 128MB blocks (doubled)
             4096,               // 4KB allocation units
-            vk::MemoryPropertyFlagBits::eDeviceLocal,
-            16                  // Max 16 blocks (2GB total, quadrupled)
+            vk::MemoryPropertyFlagBits::eDeviceLocal
         );
 
         // Index buffer pool: Medium allocations, device-local (increased for large models like bistro)
         configurePool(
             PoolType::INDEX_BUFFER,
             64 * 1024 * 1024,  // 64MB blocks (doubled)
             2048,               // 2KB allocation units
-            vk::MemoryPropertyFlagBits::eDeviceLocal,
-            8                   // Max 8 blocks (512MB total, quadrupled)
+            vk::MemoryPropertyFlagBits::eDeviceLocal
         );
 
         // Uniform buffer pool: Small allocations, host-visible
@@ -42,8 +40,7 @@ bool MemoryPool::initialize() {
             PoolType::UNIFORM_BUFFER,
             4 * 1024 * 1024,   // 4MB blocks
             64,                 // 64B allocation units (aligned to nonCoherentAtomSize)
-            vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
-            4                   // Max 4 blocks (16MB total)
+            vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent
         );
 
         // Staging buffer pool: Variable allocations, host-visible
@@ -52,17 +49,15 @@ bool MemoryPool::initialize() {
             PoolType::STAGING_BUFFER,
             16 * 1024 * 1024,  // 16MB blocks
             64,                 // 64B allocation units (aligned to nonCoherentAtomSize)
-            vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
-            4                   // Max 4 blocks (64MB total)
+            vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent
         );
 
         // Texture image pool: Large allocations, device-local (significantly increased for large models like bistro)
         configurePool(
             PoolType::TEXTURE_IMAGE,
             256 * 1024 * 1024, // 256MB blocks (doubled)
             4096,               // 4KB allocation units
-            vk::MemoryPropertyFlagBits::eDeviceLocal,
-            24                  // Max 24 blocks (6GB total, 6x increase)
+            vk::MemoryPropertyFlagBits::eDeviceLocal
         );
 
         return true;
@@ -76,14 +71,12 @@ void MemoryPool::configurePool(
     const PoolType poolType,
     const vk::DeviceSize blockSize,
     const vk::DeviceSize allocationUnit,
-    const vk::MemoryPropertyFlags properties,
-    const uint32_t maxBlocks) {
+    const vk::MemoryPropertyFlags properties) {
 
     PoolConfig config;
     config.blockSize = blockSize;
     config.allocationUnit = allocationUnit;
     config.properties = properties;
-    config.maxBlocks = maxBlocks;
 
     poolConfigs[poolType] = config;
 }
@@ -126,16 +119,16 @@ std::unique_ptr<MemoryPool::MemoryBlock> MemoryPool::createMemoryBlock(PoolType
 
     uint32_t memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, config.properties);
 
-    // Allocate the memory block
+    // Allocate the memory block using the device-required size
     vk::MemoryAllocateInfo allocInfo{
-        .allocationSize = blockSize,
+        .allocationSize = memRequirements.size,
         .memoryTypeIndex = memoryTypeIndex
     };
 
     // Create MemoryBlock with proper initialization to avoid default constructor issues
     auto block = std::unique_ptr<MemoryBlock>(new MemoryBlock{
         .memory = vk::raii::DeviceMemory(device, allocInfo),
-        .size = blockSize,
+        .size = memRequirements.size,
         .used = 0,
         .memoryTypeIndex = memoryTypeIndex,
         .isMapped = false,
@@ -147,24 +140,23 @@ std::unique_ptr<MemoryPool::MemoryBlock> MemoryPool::createMemoryBlock(PoolType
     // Map memory if it's host-visible
     block->isMapped = (config.properties & vk::MemoryPropertyFlagBits::eHostVisible) != vk::MemoryPropertyFlags{};
     if (block->isMapped) {
-        block->mappedPtr = block->memory.mapMemory(0, blockSize);
+        block->mappedPtr = block->memory.mapMemory(0, memRequirements.size);
     } else {
         block->mappedPtr = nullptr;
     }
 
-    // Initialize a free list
-    const size_t numUnits = blockSize / config.allocationUnit;
+    // Initialize a free list based on the actual allocated size
+    const size_t numUnits = static_cast<size_t>(block->size / config.allocationUnit);
     block->freeList.resize(numUnits, true);  // All units initially free
 
 
     return block;
 }
 
-MemoryPool::MemoryBlock* MemoryPool::findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment) {
+std::pair<MemoryPool::MemoryBlock*, size_t> MemoryPool::findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment) {
     auto poolIt = pools.find(poolType);
     if (poolIt == pools.end()) {
-        pools[poolType] = std::vector<std::unique_ptr<MemoryBlock>>();
-        poolIt = pools.find(poolType);
+        poolIt = pools.try_emplace( poolType ).first;
     }
 
     auto& poolBlocks = poolIt->second;
@@ -178,47 +170,39 @@ MemoryPool::MemoryBlock* MemoryPool::findSuitableBlock(PoolType poolType, vk::De
     for (const auto& block : poolBlocks) {
         // Find consecutive free units
         size_t consecutiveFree = 0;
+        size_t startUnitCandidate = 0;
         for (size_t i = 0; i < block->freeList.size(); ++i) {
             if (block->freeList[i]) {
+                if (consecutiveFree == 0) {
+                    startUnitCandidate = i;
+                }
                 consecutiveFree++;
                 if (consecutiveFree >= requiredUnits) {
-                    return block.get();
+                    return {block.get(), startUnitCandidate};
                 }
             } else {
                 consecutiveFree = 0;
             }
         }
     }
 
-    // No suitable block found, create a new one if we haven't reached the limit AND rendering is not active
-    if (poolBlocks.size() < config.maxBlocks) {
-        if (renderingActive) {
-            std::cerr << "ERROR: Attempted to create new memory block during rendering! Pool type: "
-                      << static_cast<int>(poolType) << ", required size: " << alignedSize << std::endl;
-            std::cerr << "This violates the constraint that no new memory should be allocated during PBR rendering." << std::endl;
-            return nullptr;
-        }
-
-        try {
-            auto newBlock = createMemoryBlock(poolType, alignedSize);
-            poolBlocks.push_back(std::move(newBlock));
-            std::cout << "Created new memory block during initialization (pool type: "
-                      << static_cast<int>(poolType) << ")" << std::endl;
-            return poolBlocks.back().get();
-        } catch (const std::exception& e) {
-            std::cerr << "Failed to create new memory block: " << e.what() << std::endl;
-            return nullptr;
-        }
+    // No suitable block found; create a new one on demand (no hard limits, allowed during rendering)
+    try {
+        auto newBlock = createMemoryBlock(poolType, alignedSize);
+        poolBlocks.push_back(std::move(newBlock));
+        std::cout << "Created new memory block (pool type: "
+                  << static_cast<int>(poolType) << ")" << std::endl;
+        return {poolBlocks.back().get(), 0};
+    } catch (const std::exception& e) {
+        std::cerr << "Failed to create new memory block: " << e.what() << std::endl;
+        return {nullptr, 0};
     }
-
-    std::cerr << "Memory pool exhausted for pool type " << static_cast<int>(poolType) << std::endl;
-    return nullptr;
 }
 
 std::unique_ptr<MemoryPool::Allocation> MemoryPool::allocate(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment) {
     std::lock_guard<std::mutex> lock(poolMutex);
 
-    MemoryBlock* block = findSuitableBlock(poolType, size, alignment);
+    auto [block, startUnit] = findSuitableBlock(poolType, size, alignment);
     if (!block) {
         return nullptr;
     }
@@ -229,30 +213,6 @@ std::unique_ptr<MemoryPool::Allocation> MemoryPool::allocate(PoolType poolType,
     const vk::DeviceSize alignedSize = ((size + alignment - 1) / alignment) * alignment;
     const size_t requiredUnits = (alignedSize + config.allocationUnit - 1) / config.allocationUnit;
 
-    // Find consecutive free units
-    size_t startUnit = 0;
-    size_t consecutiveFree = 0;
-    bool found = false;
-
-    for (size_t i = 0; i < block->freeList.size(); ++i) {
-        if (block->freeList[i]) {
-            if (consecutiveFree == 0) {
-                startUnit = i;
-            }
-            consecutiveFree++;
-            if (consecutiveFree >= requiredUnits) {
-                found = true;
-                break;
-            }
-        } else {
-            consecutiveFree = 0;
-        }
-    }
-
-    if (!found) {
-        return nullptr;
-    }
-
     // Mark units as used
     for (size_t i = startUnit; i < startUnit + requiredUnits; ++i) {
         block->freeList[i] = false;
@@ -427,14 +387,13 @@ bool MemoryPool::preAllocatePools() {
     std::lock_guard<std::mutex> lock(poolMutex);
 
     try {
-        std::cout << "Pre-allocating memory pools to prevent allocation during rendering..." << std::endl;
+        std::cout << "Pre-allocating initial memory blocks for pools..." << std::endl;
 
         // Pre-allocate at least one block for each pool type
         for (const auto& [poolType, config] : poolConfigs) {
             auto poolIt = pools.find(poolType);
             if (poolIt == pools.end()) {
-                pools[poolType] = std::vector<std::unique_ptr<MemoryBlock>>();
-                poolIt = pools.find(poolType);
+                poolIt = pools.try_emplace( poolType ).first;
             }
 
             auto& poolBlocks = poolIt->second;

attachments/simple_engine/memory_pool.h

@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <mutex>
 #include <cstdint>
+#include <utility>
 
 /**
  * @brief Memory pool allocator for Vulkan resources
@@ -62,7 +63,6 @@ class MemoryPool {
         vk::DeviceSize blockSize;           // Size of each memory block
         vk::DeviceSize allocationUnit;      // Minimum allocation unit
         vk::MemoryPropertyFlags properties; // Memory properties
-        uint32_t maxBlocks;                 // Maximum number of blocks
     };
 
     // Memory pools for different types
@@ -72,13 +72,13 @@ class MemoryPool {
     // Thread safety
     mutable std::mutex poolMutex;
 
-    // Rendering state tracking to prevent pool growth during rendering
+    // Optional rendering state flag (no allocation restrictions enforced)
     bool renderingActive = false;
 
     // Helper methods
     uint32_t findMemoryType(uint32_t typeFilter, vk::MemoryPropertyFlags properties) const;
     std::unique_ptr<MemoryBlock> createMemoryBlock(PoolType poolType, vk::DeviceSize size);
-    MemoryBlock* findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment);
+    std::pair<MemoryBlock*, size_t> findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment);
 
 public:
     /**
@@ -165,30 +165,28 @@ class MemoryPool {
      * @param blockSize Size of each memory block
      * @param allocationUnit Minimum allocation unit
      * @param properties Memory properties
-     * @param maxBlocks Maximum number of blocks
      */
     void configurePool(
         PoolType poolType,
         vk::DeviceSize blockSize,
         vk::DeviceSize allocationUnit,
-        vk::MemoryPropertyFlags properties,
-        uint32_t maxBlocks
+        vk::MemoryPropertyFlags properties
     );
 
     /**
-     * @brief Pre-allocate memory pools to prevent allocation during rendering
+     * @brief Pre-allocate initial memory blocks for configured pools
      * @return True if pre-allocation was successful
      */
     bool preAllocatePools();
 
     /**
-     * @brief Set rendering active state to prevent pool growth
+     * @brief Set rendering active state flag (informational only)
      * @param active Whether rendering is currently active
      */
     void setRenderingActive(bool active);
 
     /**
-     * @brief Check if rendering is currently active
+     * @brief Check if rendering is currently active (informational only)
      * @return True if rendering is active
      */
     bool isRenderingActive() const;

attachments/simple_engine/renderer_core.cpp

@@ -83,7 +83,7 @@ bool Renderer::Initialize(const std::string& appName, bool enableValidationLayer
             return false;
         }
 
-        // Pre-allocate memory pools to prevent allocation during rendering
+        // Optionally pre-allocate initial memory blocks for pools
         if (!memoryPool->preAllocatePools()) {
             std::cerr << "Failed to pre-allocate memory pools" << std::endl;
             return false;

attachments/simple_engine/renderer_rendering.cpp

@@ -505,7 +505,7 @@ void Renderer::updateUniformBufferInternal(uint32_t currentImage, Entity* entity
 
 // Render the scene
 void Renderer::Render(const std::vector<std::unique_ptr<Entity>>& entities, CameraComponent* camera, ImGuiSystem* imguiSystem) {
-    // Set rendering active to prevent memory pool growth during rendering
+    // Mark rendering as active (informational flag for systems that care)
     if (memoryPool) {
         memoryPool->setRenderingActive(true);
     }

attachments/simple_engine/renderer_resources.cpp

@@ -1420,12 +1420,6 @@ std::pair<vk::raii::Buffer, vk::raii::DeviceMemory> Renderer::createBuffer(
         throw std::runtime_error("Memory pool not available - cannot create buffer");
     }
 
-    // Check if we're trying to allocate during rendering
-    if (memoryPool->isRenderingActive()) {
-        std::cerr << "ERROR: Attempted to create buffer during rendering! Size: " << size << " bytes" << std::endl;
-        std::cerr << "This violates the constraint that no new memory should be allocated during rendering." << std::endl;
-        throw std::runtime_error("Buffer creation attempted during rendering - this is not allowed");
-    }
 
     // Only allow direct allocation for staging buffers (temporary, host-visible)
     if (!(properties & vk::MemoryPropertyFlagBits::eHostVisible)) {