gpu-tracker.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/core/log.h"
 
#include <SDL3/SDL_gpu.h>
 
#include <string>
#include <unordered_map>
 
#ifdef FLINT_ENABLE_GPU_TRACKER
class GPUResourceTracker {
  public:
    static GPUResourceTracker &instance() {
      static GPUResourceTracker tracker;
      return tracker;
    }
 
    void trackBuffer(SDL_GPUBuffer *buffer, const std::string &location) {
      if (!buffer) {
        return;
      }
      m_buffers[buffer] = location;
      FLINT_ENGINE_INFO("[GPU TRACK] Buffer {} CREATED at {}", static_cast<void *>(buffer),
                        location);
    }
 
    void releaseBuffer(SDL_GPUBuffer *buffer, const std::string &location) {
      if (!buffer) {
        return;
      }
      auto it = m_buffers.find(buffer);
      if (it != m_buffers.end()) {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Buffer {} RELEASED at {} (was created at {})",
                           static_cast<void *>(buffer), location, it->second);
        m_buffers.erase(it);
      } else {
        FLINT_ENGINE_DEBUG(
            "[GPU TRACK] Buffer {} RELEASED at {} but was NOT TRACKED (SDL internal?)",
            static_cast<void *>(buffer), location);
      }
    }
 
    void trackTexture(SDL_GPUTexture *texture, const std::string &location) {
      if (!texture) {
        return;
      }
      m_textures[texture] = location;
      FLINT_ENGINE_INFO("[GPU TRACK] Texture {} CREATED at {}", static_cast<void *>(texture),
                        location);
    }
 
    void releaseTexture(SDL_GPUTexture *texture, const std::string &location) {
      if (!texture) {
        return;
      }
      auto it = m_textures.find(texture);
      if (it != m_textures.end()) {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Texture {} RELEASED at {} (was created at {})",
                           static_cast<void *>(texture), location, it->second);
        m_textures.erase(it);
      } else {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Texture {} RELEASED at {} but was NOT TRACKED",
                           static_cast<void *>(texture), location);
      }
    }
 
    void trackSampler(SDL_GPUSampler *sampler, const std::string &location) {
      if (!sampler) {
        return;
      }
      m_samplers[sampler] = location;
      FLINT_ENGINE_DEBUG("[GPU TRACK] Sampler {} CREATED at {}", static_cast<void *>(sampler),
                         location);
    }
 
    void releaseSampler(SDL_GPUSampler *sampler, const std::string &location) {
      if (!sampler) {
        return;
      }
      auto it = m_samplers.find(sampler);
      if (it != m_samplers.end()) {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Sampler {} RELEASED at {} (was created at {})",
                           static_cast<void *>(sampler), location, it->second);
        m_samplers.erase(it);
      } else {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Sampler {} RELEASED at {} but was NOT TRACKED",
                           static_cast<void *>(sampler), location);
      }
    }
 
    void trackShader(SDL_GPUShader *shader, const std::string &location) {
      if (!shader) {
        return;
      }
      m_shaders[shader] = location;
      FLINT_ENGINE_DEBUG("[GPU TRACK] Shader {} CREATED at {}", static_cast<void *>(shader),
                         location);
    }
 
    void releaseShader(SDL_GPUShader *shader, const std::string &location) {
      if (!shader) {
        return;
      }
      auto it = m_shaders.find(shader);
      if (it != m_shaders.end()) {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Shader {} RELEASED at {} (was created at {})",
                           static_cast<void *>(shader), location, it->second);
        m_shaders.erase(it);
      } else {
        FLINT_ENGINE_DEBUG("[GPU TRACK] Shader {} RELEASED at {} but was NOT TRACKED",
                           static_cast<void *>(shader), location);
      }
    }
 
    void reportLeaks() {
      bool hasLeaks = false;
 
      if (!m_buffers.empty()) {
        hasLeaks = true;
        FLINT_ENGINE_ERROR("╔═══════════════════════════════════════════╗");
        FLINT_ENGINE_ERROR("║   GPU BUFFER LEAKS DETECTED: {}           ║", m_buffers.size());
        FLINT_ENGINE_ERROR("╚═══════════════════════════════════════════╝");
        for (const auto &[buffer, location] : m_buffers) {
          FLINT_ENGINE_ERROR("  → Buffer {} created at {}", static_cast<void *>(buffer), location);
        }
      }
 
      if (!m_textures.empty()) {
        hasLeaks = true;
        FLINT_ENGINE_ERROR("╔═══════════════════════════════════════════╗");
        FLINT_ENGINE_ERROR("║   GPU TEXTURE LEAKS DETECTED: {}          ║", m_textures.size());
        FLINT_ENGINE_ERROR("╚═══════════════════════════════════════════╝");
        for (const auto &[texture, location] : m_textures) {
          FLINT_ENGINE_ERROR("  → Texture {} created at {}", static_cast<void *>(texture),
                             location);
        }
      }
 
      if (!m_samplers.empty()) {
        hasLeaks = true;
        FLINT_ENGINE_ERROR("╔═══════════════════════════════════════════╗");
        FLINT_ENGINE_ERROR("║   GPU SAMPLER LEAKS DETECTED: {}          ║", m_samplers.size());
        FLINT_ENGINE_ERROR("╚═══════════════════════════════════════════╝");
        for (const auto &[sampler, location] : m_samplers) {
          FLINT_ENGINE_ERROR("  → Sampler {} created at {}", static_cast<void *>(sampler),
                             location);
        }
      }
 
      if (!m_shaders.empty()) {
        hasLeaks = true;
        FLINT_ENGINE_ERROR("╔═══════════════════════════════════════════╗");
        FLINT_ENGINE_ERROR("║   GPU SHADER LEAKS DETECTED: {}           ║", m_shaders.size());
        FLINT_ENGINE_ERROR("╚═══════════════════════════════════════════╝");
        for (const auto &[shader, location] : m_shaders) {
          FLINT_ENGINE_ERROR("  → Shader {} created at {}", static_cast<void *>(shader), location);
        }
      }
 
      if (!hasLeaks) {
        FLINT_ENGINE_INFO("╔═══════════════════════════════════════════╗");
        FLINT_ENGINE_INFO("║   ✓ NO GPU RESOURCE LEAKS DETECTED!       ║");
        FLINT_ENGINE_INFO("╚═══════════════════════════════════════════╝");
      } else {
        FLINT_ENGINE_ERROR("");
        FLINT_ENGINE_ERROR("NOTE: If Vulkan validation shows leaks but tracker doesn't,");
        FLINT_ENGINE_ERROR("      those are SDL3/driver internal resources, not your code!");
      }
    }
 
  private:
    std::unordered_map<SDL_GPUBuffer *, std::string>  m_buffers;
    std::unordered_map<SDL_GPUTexture *, std::string> m_textures;
    std::unordered_map<SDL_GPUSampler *, std::string> m_samplers;
    std::unordered_map<SDL_GPUShader *, std::string>  m_shaders;
};
 
  #define GPU_TRACK_LOCATION (std::string(__FILE__) + ":" + std::to_string(__LINE__))
 
  #define GPU_TRACK_BUFFER(buffer, name)                                                           \
    GPUResourceTracker::instance().trackBuffer(buffer, GPU_TRACK_LOCATION)
 
  #define GPU_RELEASE_BUFFER(device, buffer)                                                       \
    do {                                                                                           \
      GPUResourceTracker::instance().releaseBuffer(buffer, GPU_TRACK_LOCATION);                    \
      SDL_ReleaseGPUBuffer(device, buffer);                                                        \
    } while (0)
 
  #define GPU_TRACK_TEXTURE(texture, name)                                                         \
    GPUResourceTracker::instance().trackTexture(texture, GPU_TRACK_LOCATION)
 
  #define GPU_RELEASE_TEXTURE(device, texture)                                                     \
    do {                                                                                           \
      GPUResourceTracker::instance().releaseTexture(texture, GPU_TRACK_LOCATION);                  \
      SDL_ReleaseGPUTexture(device, texture);                                                      \
    } while (0)
 
  #define GPU_TRACK_SAMPLER(sampler, name)                                                         \
    GPUResourceTracker::instance().trackSampler(sampler, GPU_TRACK_LOCATION)
 
  #define GPU_RELEASE_SAMPLER(device, sampler)                                                     \
    do {                                                                                           \
      GPUResourceTracker::instance().releaseSampler(sampler, GPU_TRACK_LOCATION);                  \
      SDL_ReleaseGPUSampler(device, sampler);                                                      \
    } while (0)
 
  #define GPU_TRACK_SHADER(shader, name)                                                           \
    GPUResourceTracker::instance().trackShader(shader, GPU_TRACK_LOCATION)
 
  #define GPU_RELEASE_SHADER(device, shader)                                                       \
    do {                                                                                           \
      GPUResourceTracker::instance().releaseShader(shader, GPU_TRACK_LOCATION);                    \
      SDL_ReleaseGPUShader(device, shader);                                                        \
    } while (0)
 
  #define GPU_REPORT_LEAKS() GPUResourceTracker::instance().reportLeaks()
 
#else
 
  #define GPU_TRACK_BUFFER(buffer, name)
  #define GPU_RELEASE_BUFFER(device, buffer) SDL_ReleaseGPUBuffer(device, buffer)
  #define GPU_TRACK_TEXTURE(texture, name)
  #define GPU_RELEASE_TEXTURE(device, texture) SDL_ReleaseGPUTexture(device, texture)
  #define GPU_TRACK_SAMPLER(sampler, name)
  #define GPU_RELEASE_SAMPLER(device, sampler) SDL_ReleaseGPUSampler(device, sampler)
  #define GPU_TRACK_SHADER(shader, name)
  #define GPU_RELEASE_SHADER(device, shader) SDL_ReleaseGPUShader(device, shader)
  #define GPU_REPORT_LEAKS()
 
#endif