ComputeDebugUtils.h

Go to the documentation of this file.

#pragma once
 
#include <Engine/Core/Settings.h>
 
#ifdef COMPUTE_DEBUG
 
#include <Engine/Renderer/VulkanBuffer.h>
#include <plog/Log.h>
#include <vector>
#include <vulkan/vulkan_core.h>
 
namespace EngineCore::ComputeDebug
{
    template <typename T>
    std::vector<T> readbackBuffer(
        VkDevice         device,
        VkPhysicalDevice physicalDevice,
        const VulkanBuffer & buffer,
        size_t           count
    );

    void logObjectCullingResults( uint32_t objectCount, uint32_t survivingCount );

    void logMeshletCullingResults( uint32_t meshletCount, uint32_t visibleCount );

    void logCounter( const char * name, uint32_t value );

    uint32_t readbackCounter(
        VkDevice             device,
        VkPhysicalDevice     physicalDevice,
        const VulkanBuffer & buffer
    );
 
}  // namespace EngineCore::ComputeDebug
 
// Template implementation
namespace EngineCore::ComputeDebug
{
    template <typename T>
    std::vector<T> readbackBuffer(
        VkDevice             device,
        VkPhysicalDevice     physicalDevice,
        const VulkanBuffer & buffer,
        size_t               count
    )
    {
        std::vector<T> result( count );
 
        const VkDeviceSize bufferSize = count * sizeof( T );
 
        // Create staging buffer for readback
        VkBufferCreateInfo stagingBufferInfo{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
        stagingBufferInfo.size        = bufferSize;
        stagingBufferInfo.usage       = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        stagingBufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
        VkBuffer stagingBuffer;
        if ( vkCreateBuffer( device, &stagingBufferInfo, nullptr, &stagingBuffer ) != VK_SUCCESS )
        {
            PLOGE << "Failed to create staging buffer for readback";
            return result;
        }
 
        VkMemoryRequirements memRequirements;
        vkGetBufferMemoryRequirements( device, stagingBuffer, &memRequirements );
 
        VkPhysicalDeviceMemoryProperties memProperties;
        vkGetPhysicalDeviceMemoryProperties( physicalDevice, &memProperties );
 
        uint32_t memoryTypeIndex = UINT32_MAX;
        for ( uint32_t i = 0; i < memProperties.memoryTypeCount; i++ )
        {
            if ( ( memRequirements.memoryTypeBits & ( 1 << i ) ) &&
                 ( memProperties.memoryTypes[i].propertyFlags &
                   ( VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ) ) ==
                     ( VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ) )
            {
                memoryTypeIndex = i;
                break;
            }
        }
 
        if ( memoryTypeIndex == UINT32_MAX )
        {
            PLOGE << "Failed to find suitable memory type for readback buffer";
            vkDestroyBuffer( device, stagingBuffer, nullptr );
            return result;
        }
 
        VkMemoryAllocateInfo allocInfo{ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        allocInfo.allocationSize  = memRequirements.size;
        allocInfo.memoryTypeIndex = memoryTypeIndex;
 
        VkDeviceMemory stagingMemory;
        if ( vkAllocateMemory( device, &allocInfo, nullptr, &stagingMemory ) != VK_SUCCESS )
        {
            PLOGE << "Failed to allocate staging memory for readback";
            vkDestroyBuffer( device, stagingBuffer, nullptr );
            return result;
        }
 
        vkBindBufferMemory( device, stagingBuffer, stagingMemory, 0 );
 
        // Map memory and copy
        void * mappedData;
        vkMapMemory( device, stagingMemory, 0, bufferSize, 0, &mappedData );
 
        // Note: In a real implementation, we'd need to copy from GPU buffer to staging
        // This requires a command buffer submission. For now, we assume the buffer
        // is already host-visible or this is called after a proper copy.
        
        // For host-visible buffers, we can read directly from the buffer's mapped memory
        // This is a simplified version - full implementation would use vkCmdCopyBuffer
 
        memcpy( result.data(), mappedData, bufferSize );
 
        vkUnmapMemory( device, stagingMemory );
 
        // Cleanup
        vkDestroyBuffer( device, stagingBuffer, nullptr );
        vkFreeMemory( device, stagingMemory, nullptr );
 
        return result;
    }
}  // namespace EngineCore::ComputeDebug
 
#endif  // COMPUTE_DEBUG