MemoryProfiling.cpp

Go to the documentation of this file.

#ifdef ENABLE_TRACY
 
#include <iostream>
#include <cstdlib>
#include <new>
#include <mutex>
 
#include <tracy/Tracy.hpp>  // Assuming Tracy headers are in your include path
#include <Engine/Profiler/MemoryProfiling.h>
 
/*std::mutex tracy_mutex; // Mutex for thread safety
 
// Regular new/delete
void* operator new(std::size_t count) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = std::malloc(count);
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete(void* ptr) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    std::free(ptr);
}
 
// Array new/delete
void* operator new[](std::size_t count) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = std::malloc(count);
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete[](void* ptr) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    std::free(ptr);
}
 
// Placement new/delete (noexcept)
void* operator new(std::size_t count, const std::nothrow_t& tag) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = std::malloc(count);
    if (!ptr) return nullptr; // Important for noexcept
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete(void* ptr, const std::nothrow_t& tag) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    std::free(ptr);
}
 
void* operator new[](std::size_t count, const std::nothrow_t& tag) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = std::malloc(count);
    if (!ptr) return nullptr; // Important for noexcept
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete[](void* ptr, const std::nothrow_t& tag) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    std::free(ptr);
}
 
 
// Aligned new/delete
#ifdef _WIN32
#include <malloc.h> // For _aligned_malloc, _aligned_free (Windows)
 
void* operator new(std::size_t count, std::align_val_t al) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = _aligned_malloc(count, static_cast<size_t>(al));
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete(void* ptr, std::align_val_t al) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    _aligned_free(ptr);
}
 
void* operator new[](std::size_t count, std::align_val_t al) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = _aligned_malloc(count, static_cast<size_t>(al));
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete[](void* ptr, std::align_val_t al) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    _aligned_free(ptr);
}
 
#else // Linux/macOS (POSIX)
#include <stdlib.h> // For aligned_alloc, free
 
void* operator new(std::size_t count, std::align_val_t al) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = aligned_alloc(static_cast<size_t>(al), count);
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete(void* ptr, std::align_val_t al) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    free(ptr); // Use free, not aligned_free
}
 
void* operator new[](std::size_t count, std::align_val_t al) {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    void* ptr = aligned_alloc(static_cast<size_t>(al), count);
    if (!ptr) throw std::bad_alloc{};
    TracyAlloc(ptr, count);
    return ptr;
}
 
void operator delete[](void* ptr, std::align_val_t al) noexcept {
    std::lock_guard<std::mutex> lock(tracy_mutex);
    TracyFree(ptr);
    free(ptr); // Use free, not aligned_free
}
#endif
*/
#endif