From a091bb4ad23dae9f7299e1186bd9fc97f4456511 Mon Sep 17 00:00:00 2001 From: Bartosz Taudul Date: Fri, 12 Jun 2026 19:41:17 +0200 Subject: [PATCH] Remove "secure" variant of alloc/free. Random crashes are not fun. Always use the "secure" code path. --- manual/tracy.tex | 10 ++---- public/TracyClient.F90 | 52 +++++++++------------------- public/client/TracyProfiler.cpp | 40 +++++++++++----------- public/client/TracyProfiler.hpp | 52 ++++++++++++++-------------- public/tracy/Tracy.hpp | 40 ++++++---------------- public/tracy/TracyC.h | 60 +++++++++++---------------------- 6 files changed, 95 insertions(+), 159 deletions(-) diff --git a/manual/tracy.tex b/manual/tracy.tex index 34c61db2..9b873cd5 100644 --- a/manual/tracy.tex +++ b/manual/tracy.tex @@ -1609,8 +1609,6 @@ void operator delete(void* ptr) noexcept } \end{lstlisting} -In some rare cases (e.g., destruction of TLS block), events may be reported after the profiler is no longer available, which would lead to a crash. To work around this issue, you may use \texttt{TracySecureAlloc} and \texttt{TracySecureFree} variants of the macros. - \begin{bclogo}[ noborder=true, couleur=black!5, @@ -1889,7 +1887,7 @@ As you can see, there are two threads, \texttt{t1} and \texttt{t2}, which are si \subsection{Collecting call stacks} \label{collectingcallstacks} -Capture of true calls stacks can be performed by using macros with the \texttt{S} postfix, which require an additional parameter, specifying the depth of call stack to be captured. The greater the depth, the longer it will take to perform capture. Currently you can use the following macros: \texttt{ZoneScopedS}, \texttt{ZoneScopedNS}, \texttt{ZoneScopedCS}, \texttt{ZoneScopedNCS}, \texttt{TracyAllocS}, \texttt{TracyFreeS}, \texttt{TracySecureAllocS}, \texttt{TracySecureFreeS}, \texttt{TracyMessageS}, \texttt{TracyMessageLS}, \texttt{TracyMessageCS}, \texttt{TracyMessageLCS}, \texttt{TracyGpuZoneS}, \texttt{TracyGpuZoneCS}, \texttt{TracyVkZoneS}, \texttt{TracyVkZoneCS}, and the named and transient variants. +Capture of true calls stacks can be performed by using macros with the \texttt{S} postfix, which require an additional parameter, specifying the depth of call stack to be captured. The greater the depth, the longer it will take to perform capture. Currently you can use the following macros: \texttt{ZoneScopedS}, \texttt{ZoneScopedNS}, \texttt{ZoneScopedCS}, \texttt{ZoneScopedNCS}, \texttt{TracyAllocS}, \texttt{TracyFreeS}, \texttt{TracyMessageS}, \texttt{TracyMessageLS}, \texttt{TracyMessageCS}, \texttt{TracyMessageLCS}, \texttt{TracyGpuZoneS}, \texttt{TracyGpuZoneCS}, \texttt{TracyVkZoneS}, \texttt{TracyVkZoneCS}, and the named and transient variants. Be aware that call stack collection is a relatively slow operation. Table~\ref{CallstackTimes} and figure~\ref{CallstackPlot} show how long it took to perform a single capture of varying depth on multiple CPU architectures. @@ -2318,8 +2316,6 @@ Use the following macros in your implementations of \texttt{malloc} and \texttt{ \begin{itemize} \item \texttt{TracyCAlloc(ptr, size)} \item \texttt{TracyCFree(ptr)} -\item \texttt{TracyCSecureAlloc(ptr, size)} -\item \texttt{TracyCSecureFree(ptr)} \end{itemize} Correctly using this functionality can be pretty tricky. You also will need to handle all the memory allocations made by external libraries (which typically allow usage of custom memory allocation functions) and the allocations made by system functions. If you can't track such an allocation, you will need to make sure freeing is not reported\footnote{It's not uncommon to see a pattern where a system function returns some allocated memory, which you then need to release.}. @@ -2879,8 +2875,8 @@ logo=\bclampe Use the following calls in your implementations of allocator/deallocator: \begin{itemize} -\item \texttt{tracy\_memory\_alloc(ptr, size, name, depth, secure)} -\item \texttt{tracy\_memory\_free(ptr, name, depth, secure)} +\item \texttt{tracy\_memory\_alloc(ptr, size, name, depth)} +\item \texttt{tracy\_memory\_free(ptr, name, depth)} \end{itemize} Correctly using this functionality can be pretty tricky especially in Fortran. diff --git a/public/TracyClient.F90 b/public/TracyClient.F90 index 7c24648a..f98dabcc 100644 --- a/public/TracyClient.F90 +++ b/public/TracyClient.F90 @@ -861,43 +861,38 @@ module tracy end interface interface - subroutine impl_tracy_emit_memory_alloc_callstack(ptr, size, depth, secure) & + subroutine impl_tracy_emit_memory_alloc_callstack(ptr, size, depth) & bind(C, name="___tracy_emit_memory_alloc_callstack") import type(c_ptr), intent(in), value :: ptr integer(c_size_t), intent(in), value :: size integer(c_int32_t), intent(in), value :: depth - integer(c_int32_t), intent(in), value :: secure end subroutine impl_tracy_emit_memory_alloc_callstack - subroutine impl_tracy_emit_memory_alloc_callstack_named(ptr, size, depth, secure, name) & + subroutine impl_tracy_emit_memory_alloc_callstack_named(ptr, size, depth, name) & bind(C, name="___tracy_emit_memory_alloc_callstack_named") import type(c_ptr), intent(in), value :: ptr integer(c_size_t), intent(in), value :: size integer(c_int32_t), intent(in), value :: depth - integer(c_int32_t), intent(in), value :: secure type(c_ptr), intent(in), value :: name end subroutine impl_tracy_emit_memory_alloc_callstack_named - subroutine impl_tracy_emit_memory_free_callstack(ptr, depth, secure) & + subroutine impl_tracy_emit_memory_free_callstack(ptr, depth) & bind(C, name="___tracy_emit_memory_free_callstack") import type(c_ptr), intent(in), value :: ptr integer(c_int32_t), intent(in), value :: depth - integer(c_int32_t), intent(in), value :: secure end subroutine impl_tracy_emit_memory_free_callstack - subroutine impl_tracy_emit_memory_free_callstack_named(ptr, depth, secure, name) & + subroutine impl_tracy_emit_memory_free_callstack_named(ptr, depth, name) & bind(C, name="___tracy_emit_memory_free_callstack_named") import type(c_ptr), intent(in), value :: ptr integer(c_int32_t), intent(in), value :: depth - integer(c_int32_t), intent(in), value :: secure type(c_ptr), intent(in), value :: name end subroutine impl_tracy_emit_memory_free_callstack_named - subroutine impl_tracy_emit_memory_discard_callstack(name, secure, depth) & + subroutine impl_tracy_emit_memory_discard_callstack(name, depth) & bind(C, name="___tracy_emit_memory_discard_callstack") import type(c_ptr), intent(in), value :: name - integer(c_int32_t), intent(in), value :: secure integer(c_int32_t), intent(in), value :: depth end subroutine impl_tracy_emit_memory_discard_callstack end interface @@ -1128,58 +1123,43 @@ contains tracy_connected = impl_tracy_connected() /= 0_c_int32_t end function tracy_connected - subroutine tracy_memory_alloc(ptr, size, name, depth, secure) + subroutine tracy_memory_alloc(ptr, size, name, depth) type(c_ptr), intent(in) :: ptr integer(c_size_t), intent(in) :: size character(kind=c_char, len=*), target, intent(in), optional :: name integer(c_int32_t), intent(in), optional :: depth - logical(1), intent(in), optional :: secure ! - integer(c_int32_t) :: depth_, secure_ - secure_ = 0_c_int32_t + integer(c_int32_t) :: depth_ depth_ = 0_c_int32_t - if (present(secure)) then - if (secure) secure_ = 1_c_int32_t - end if if (present(depth)) depth_ = depth if (present(name)) then - call impl_tracy_emit_memory_alloc_callstack_named(ptr, size, depth_, secure_, c_loc(name)) + call impl_tracy_emit_memory_alloc_callstack_named(ptr, size, depth_, c_loc(name)) else - call impl_tracy_emit_memory_alloc_callstack(ptr, size, depth_, secure_) + call impl_tracy_emit_memory_alloc_callstack(ptr, size, depth_) end if end subroutine tracy_memory_alloc - subroutine tracy_memory_free(ptr, name, depth, secure) + subroutine tracy_memory_free(ptr, name, depth) type(c_ptr), intent(in) :: ptr character(kind=c_char, len=*), target, intent(in), optional :: name integer(c_int32_t), intent(in), optional :: depth - logical(1), intent(in), optional :: secure ! - integer(c_int32_t) :: depth_, secure_ - secure_ = 0_c_int32_t + integer(c_int32_t) :: depth_ depth_ = 0_c_int32_t - if (present(secure)) then - if (secure) secure_ = 1_c_int32_t - end if if (present(depth)) depth_ = depth if (present(name)) then - call impl_tracy_emit_memory_free_callstack_named(ptr, depth_, secure_, c_loc(name)) + call impl_tracy_emit_memory_free_callstack_named(ptr, depth_, c_loc(name)) else - call impl_tracy_emit_memory_free_callstack(ptr, depth_, secure_) + call impl_tracy_emit_memory_free_callstack(ptr, depth_) end if end subroutine tracy_memory_free - subroutine tracy_memory_discard(name, depth, secure) + subroutine tracy_memory_discard(name, depth) character(kind=c_char, len=*), target, intent(in) :: name integer(c_int32_t), intent(in), optional :: depth - logical(1), intent(in), optional :: secure ! - integer(c_int32_t) :: depth_, secure_ - secure_ = 0_c_int32_t + integer(c_int32_t) :: depth_ depth_ = 0_c_int32_t - if (present(secure)) then - if (secure) secure_ = 1_c_int32_t - end if if (present(depth)) depth_ = depth - call impl_tracy_emit_memory_discard_callstack(c_loc(name), depth_, secure_) + call impl_tracy_emit_memory_discard_callstack(c_loc(name), depth_) end subroutine tracy_memory_discard subroutine tracy_message(msg, color, depth) diff --git a/public/client/TracyProfiler.cpp b/public/client/TracyProfiler.cpp index 3187ed21..d511b25a 100644 --- a/public/client/TracyProfiler.cpp +++ b/public/client/TracyProfiler.cpp @@ -4709,64 +4709,64 @@ TRACY_API void ___tracy_emit_zone_value( TracyCZoneCtx ctx, uint64_t value ) } } -TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size, int32_t secure ) { tracy::Profiler::MemAlloc( ptr, size, secure != 0 ); } -TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int32_t depth, int32_t secure ) +TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size ) { tracy::Profiler::MemAlloc( ptr, size ); } +TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int32_t depth ) { if( depth > 0 && tracy::has_callstack() ) { - tracy::Profiler::MemAllocCallstack( ptr, size, depth, secure != 0 ); + tracy::Profiler::MemAllocCallstack( ptr, size, depth ); } else { - tracy::Profiler::MemAlloc( ptr, size, secure != 0 ); + tracy::Profiler::MemAlloc( ptr, size ); } } -TRACY_API void ___tracy_emit_memory_free( const void* ptr, int32_t secure ) { tracy::Profiler::MemFree( ptr, secure != 0 ); } -TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int32_t depth, int32_t secure ) +TRACY_API void ___tracy_emit_memory_free( const void* ptr ) { tracy::Profiler::MemFree( ptr ); } +TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int32_t depth ) { if( depth > 0 && tracy::has_callstack() ) { - tracy::Profiler::MemFreeCallstack( ptr, depth, secure != 0 ); + tracy::Profiler::MemFreeCallstack( ptr, depth ); } else { - tracy::Profiler::MemFree( ptr, secure != 0 ); + tracy::Profiler::MemFree( ptr ); } } -TRACY_API void ___tracy_emit_memory_discard( const char* name, int32_t secure ) { tracy::Profiler::MemDiscard( name, secure != 0 ); } -TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int32_t secure, int32_t depth ) +TRACY_API void ___tracy_emit_memory_discard( const char* name ) { tracy::Profiler::MemDiscard( name ); } +TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int32_t depth ) { if( depth > 0 && tracy::has_callstack() ) { - tracy::Profiler::MemDiscardCallstack( name, secure != 0, depth ); + tracy::Profiler::MemDiscardCallstack( name, depth ); } else { - tracy::Profiler::MemDiscard( name, secure != 0 ); + tracy::Profiler::MemDiscard( name ); } } -TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int32_t secure, const char* name ) { tracy::Profiler::MemAllocNamed( ptr, size, secure != 0, name ); } -TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int32_t depth, int32_t secure, const char* name ) +TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, const char* name ) { tracy::Profiler::MemAllocNamed( ptr, size, name ); } +TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int32_t depth, const char* name ) { if( depth > 0 && tracy::has_callstack() ) { - tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, secure != 0, name ); + tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, name ); } else { - tracy::Profiler::MemAllocNamed( ptr, size, secure != 0, name ); + tracy::Profiler::MemAllocNamed( ptr, size, name ); } } -TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int32_t secure, const char* name ) { tracy::Profiler::MemFreeNamed( ptr, secure != 0, name ); } -TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int32_t depth, int32_t secure, const char* name ) +TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, const char* name ) { tracy::Profiler::MemFreeNamed( ptr, name ); } +TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int32_t depth, const char* name ) { if( depth > 0 && tracy::has_callstack() ) { - tracy::Profiler::MemFreeCallstackNamed( ptr, depth, secure != 0, name ); + tracy::Profiler::MemFreeCallstackNamed( ptr, depth, name ); } else { - tracy::Profiler::MemFreeNamed( ptr, secure != 0, name ); + tracy::Profiler::MemFreeNamed( ptr, name ); } } TRACY_API void ___tracy_emit_frame_mark( const char* name ) { tracy::Profiler::SendFrameMark( name ); } diff --git a/public/client/TracyProfiler.hpp b/public/client/TracyProfiler.hpp index f1a221a8..8d40392f 100644 --- a/public/client/TracyProfiler.hpp +++ b/public/client/TracyProfiler.hpp @@ -535,9 +535,9 @@ public: TracyLfqCommit; } - static tracy_force_inline void MemAlloc( const void* ptr, size_t size, bool secure ) + static tracy_force_inline void MemAlloc( const void* ptr, size_t size ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; #endif @@ -548,9 +548,9 @@ public: GetProfiler().m_serialLock.unlock(); } - static tracy_force_inline void MemFree( const void* ptr, bool secure ) + static tracy_force_inline void MemFree( const void* ptr ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; #endif @@ -561,9 +561,9 @@ public: GetProfiler().m_serialLock.unlock(); } - static tracy_force_inline void MemAllocCallstack( const void* ptr, size_t size, int32_t depth, bool secure ) + static tracy_force_inline void MemAllocCallstack( const void* ptr, size_t size, int32_t depth ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; if( depth > 0 && has_callstack() ) { auto& profiler = GetProfiler(); @@ -581,16 +581,16 @@ public: } else { - MemAlloc( ptr, size, secure ); + MemAlloc( ptr, size ); } } - static tracy_force_inline void MemFreeCallstack( const void* ptr, int32_t depth, bool secure ) + static tracy_force_inline void MemFreeCallstack( const void* ptr, int32_t depth ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; if( !ProfilerAllocatorAvailable() ) { - MemFree( ptr, secure ); + MemFree( ptr ); return; } if( depth > 0 && has_callstack() ) @@ -610,13 +610,13 @@ public: } else { - MemFree( ptr, secure ); + MemFree( ptr ); } } - static tracy_force_inline void MemAllocNamed( const void* ptr, size_t size, bool secure, const char* name ) + static tracy_force_inline void MemAllocNamed( const void* ptr, size_t size, const char* name ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; #endif @@ -628,9 +628,9 @@ public: GetProfiler().m_serialLock.unlock(); } - static tracy_force_inline void MemFreeNamed( const void* ptr, bool secure, const char* name ) + static tracy_force_inline void MemFreeNamed( const void* ptr, const char* name ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; #endif @@ -642,9 +642,9 @@ public: GetProfiler().m_serialLock.unlock(); } - static tracy_force_inline void MemAllocCallstackNamed( const void* ptr, size_t size, int32_t depth, bool secure, const char* name ) + static tracy_force_inline void MemAllocCallstackNamed( const void* ptr, size_t size, int32_t depth, const char* name ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; if( depth > 0 && has_callstack() ) { auto& profiler = GetProfiler(); @@ -663,13 +663,13 @@ public: } else { - MemAllocNamed( ptr, size, secure, name ); + MemAllocNamed( ptr, size, name ); } } - static tracy_force_inline void MemFreeCallstackNamed( const void* ptr, int32_t depth, bool secure, const char* name ) + static tracy_force_inline void MemFreeCallstackNamed( const void* ptr, int32_t depth, const char* name ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; if( depth > 0 && has_callstack() ) { auto& profiler = GetProfiler(); @@ -688,13 +688,13 @@ public: } else { - MemFreeNamed( ptr, secure, name ); + MemFreeNamed( ptr, name ); } } - static tracy_force_inline void MemDiscard( const char* name, bool secure ) + static tracy_force_inline void MemDiscard( const char* name ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; #endif @@ -705,9 +705,9 @@ public: GetProfiler().m_serialLock.unlock(); } - static tracy_force_inline void MemDiscardCallstack( const char* name, bool secure, int32_t depth ) + static tracy_force_inline void MemDiscardCallstack( const char* name, int32_t depth ) { - if( secure && !ProfilerAvailable() ) return; + if( !ProfilerAvailable() ) return; if( depth > 0 && has_callstack() ) { # ifdef TRACY_ON_DEMAND @@ -724,7 +724,7 @@ public: } else { - MemDiscard( name, secure ); + MemDiscard( name ); } } diff --git a/public/tracy/Tracy.hpp b/public/tracy/Tracy.hpp index 4dcd3a55..56e090ba 100644 --- a/public/tracy/Tracy.hpp +++ b/public/tracy/Tracy.hpp @@ -76,14 +76,9 @@ #define TracyAlloc(x,y) #define TracyFree(x) #define TracyMemoryDiscard(x) -#define TracySecureAlloc(x,y) -#define TracySecureFree(x) -#define TracySecureMemoryDiscard(x) #define TracyAllocN(x,y,z) #define TracyFreeN(x,y) -#define TracySecureAllocN(x,y,z) -#define TracySecureFreeN(x,y) #define ZoneNamedS(x,y,z) #define ZoneNamedNS(x,y,z,w) @@ -101,14 +96,9 @@ #define TracyAllocS(x,y,z) #define TracyFreeS(x,y) #define TracyMemoryDiscardS(x,y) -#define TracySecureAllocS(x,y,z) -#define TracySecureFreeS(x,y) -#define TracySecureMemoryDiscardS(x,y) #define TracyAllocNS(x,y,z,w) #define TracyFreeNS(x,y,z) -#define TracySecureAllocNS(x,y,z,w) -#define TracySecureFreeNS(x,y,z) #define TracyMessageS(x,y,z) #define TracyMessageLS(x,y) @@ -221,17 +211,12 @@ #define TracyMessageC( txt, size, color ) tracy::Profiler::LogString( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, color, TRACY_CALLSTACK, size, txt ) #define TracyMessageLC( txt, color ) tracy::Profiler::LogString( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, color, TRACY_CALLSTACK, txt ) -#define TracyAlloc( ptr, size ) tracy::Profiler::MemAllocCallstack( ptr, size, TRACY_CALLSTACK, false ) -#define TracyFree( ptr ) tracy::Profiler::MemFreeCallstack( ptr, TRACY_CALLSTACK, false ) -#define TracySecureAlloc( ptr, size ) tracy::Profiler::MemAllocCallstack( ptr, size, TRACY_CALLSTACK, true ) -#define TracySecureFree( ptr ) tracy::Profiler::MemFreeCallstack( ptr, TRACY_CALLSTACK, true ) +#define TracyAlloc( ptr, size ) tracy::Profiler::MemAllocCallstack( ptr, size, TRACY_CALLSTACK ) +#define TracyFree( ptr ) tracy::Profiler::MemFreeCallstack( ptr, TRACY_CALLSTACK ) -#define TracyAllocN( ptr, size, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, TRACY_CALLSTACK, false, name ) -#define TracyFreeN( ptr, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, TRACY_CALLSTACK, false, name ) -#define TracyMemoryDiscard( name ) tracy::Profiler::MemDiscardCallstack( name, false, TRACY_CALLSTACK ) -#define TracySecureAllocN( ptr, size, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, TRACY_CALLSTACK, true, name ) -#define TracySecureFreeN( ptr, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, TRACY_CALLSTACK, true, name ) -#define TracySecureMemoryDiscard( name ) tracy::Profiler::MemDiscardCallstack( name, true, TRACY_CALLSTACK ) +#define TracyAllocN( ptr, size, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, TRACY_CALLSTACK, name ) +#define TracyFreeN( ptr, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, TRACY_CALLSTACK, name ) +#define TracyMemoryDiscard( name ) tracy::Profiler::MemDiscardCallstack( name, TRACY_CALLSTACK ) #define ZoneNamedS( varname, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { nullptr, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) #define ZoneNamedNS( varname, name, depth, active ) static constexpr tracy::SourceLocationData TracyConcat(__tracy_source_location,TracyLine) { name, TracyFunction, TracyFile, (uint32_t)TracyLine, 0 }; tracy::ScopedZone varname( &TracyConcat(__tracy_source_location,TracyLine), depth, active ) @@ -246,17 +231,12 @@ #define ZoneScopedCS( color, depth ) ZoneNamedCS( ___tracy_scoped_zone, color, depth, true ) #define ZoneScopedNCS( name, color, depth ) ZoneNamedNCS( ___tracy_scoped_zone, name, color, depth, true ) -#define TracyAllocS( ptr, size, depth ) tracy::Profiler::MemAllocCallstack( ptr, size, depth, false ) -#define TracyFreeS( ptr, depth ) tracy::Profiler::MemFreeCallstack( ptr, depth, false ) -#define TracySecureAllocS( ptr, size, depth ) tracy::Profiler::MemAllocCallstack( ptr, size, depth, true ) -#define TracySecureFreeS( ptr, depth ) tracy::Profiler::MemFreeCallstack( ptr, depth, true ) +#define TracyAllocS( ptr, size, depth ) tracy::Profiler::MemAllocCallstack( ptr, size, depth ) +#define TracyFreeS( ptr, depth ) tracy::Profiler::MemFreeCallstack( ptr, depth ) -#define TracyAllocNS( ptr, size, depth, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, false, name ) -#define TracyFreeNS( ptr, depth, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, depth, false, name ) -#define TracyMemoryDiscardS( name, depth ) tracy::Profiler::MemDiscardCallstack( name, false, depth ) -#define TracySecureAllocNS( ptr, size, depth, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, true, name ) -#define TracySecureFreeNS( ptr, depth, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, depth, true, name ) -#define TracySecureMemoryDiscardS( name, depth ) tracy::Profiler::MemDiscardCallstack( name, true, depth ) +#define TracyAllocNS( ptr, size, depth, name ) tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, name ) +#define TracyFreeNS( ptr, depth, name ) tracy::Profiler::MemFreeCallstackNamed( ptr, depth, name ) +#define TracyMemoryDiscardS( name, depth ) tracy::Profiler::MemDiscardCallstack( name, depth ) #define TracyMessageS( txt, size, depth ) tracy::Profiler::LogString( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, 0, depth, size, txt ) #define TracyMessageLS( txt, depth ) tracy::Profiler::LogString( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, 0, depth, txt ) diff --git a/public/tracy/TracyC.h b/public/tracy/TracyC.h index e477f2c8..1e94794f 100644 --- a/public/tracy/TracyC.h +++ b/public/tracy/TracyC.h @@ -64,14 +64,9 @@ typedef const void* TracyCSharedLockCtx; #define TracyCAlloc(x,y) #define TracyCFree(x) #define TracyCMemoryDiscard(x) -#define TracyCSecureAlloc(x,y) -#define TracyCSecureFree(x) -#define TracyCSecureMemoryDiscard(x) #define TracyCAllocN(x,y,z) #define TracyCFreeN(x,y) -#define TracyCSecureAllocN(x,y,z) -#define TracyCSecureFreeN(x,y) #define TracyCFrameMark #define TracyCFrameMarkNamed(x) @@ -98,14 +93,9 @@ typedef const void* TracyCSharedLockCtx; #define TracyCAllocS(x,y,z) #define TracyCFreeS(x,y) #define TracyCMemoryDiscardS(x,y) -#define TracyCSecureAllocS(x,y,z) -#define TracyCSecureFreeS(x,y) -#define TracyCSecureMemoryDiscardS(x,y) #define TracyCAllocNS(x,y,z,w) #define TracyCFreeNS(x,y,z) -#define TracyCSecureAllocNS(x,y,z,w) -#define TracyCSecureFreeNS(x,y,z) #define TracyCMessageS(x,y,z) #define TracyCMessageLS(x,y) @@ -295,31 +285,26 @@ TRACY_API int32_t ___tracy_connected(void); #define TracyCZoneValue( ctx, value ) ___tracy_emit_zone_value( ctx, value ); -TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size, int32_t secure ); -TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int32_t depth, int32_t secure ); -TRACY_API void ___tracy_emit_memory_free( const void* ptr, int32_t secure ); -TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int32_t depth, int32_t secure ); -TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int32_t secure, const char* name ); -TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int32_t depth, int32_t secure, const char* name ); -TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int32_t secure, const char* name ); -TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int32_t depth, int32_t secure, const char* name ); -TRACY_API void ___tracy_emit_memory_discard( const char* name, int32_t secure ); -TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int32_t secure, int32_t depth ); +TRACY_API void ___tracy_emit_memory_alloc( const void* ptr, size_t size ); +TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int32_t depth ); +TRACY_API void ___tracy_emit_memory_free( const void* ptr ); +TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int32_t depth ); +TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, const char* name ); +TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int32_t depth, const char* name ); +TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, const char* name ); +TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int32_t depth, const char* name ); +TRACY_API void ___tracy_emit_memory_discard( const char* name ); +TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int32_t depth ); TRACY_API void ___tracy_emit_logString( int8_t severity, int32_t color, int32_t callstack_depth, size_t size, const char* txt ); TRACY_API void ___tracy_emit_logStringL( int8_t severity, int32_t color, int32_t callstack_depth, const char* txt ); -#define TracyCAlloc( ptr, size ) ___tracy_emit_memory_alloc_callstack( ptr, size, TRACY_CALLSTACK, 0 ) -#define TracyCFree( ptr ) ___tracy_emit_memory_free_callstack( ptr, TRACY_CALLSTACK, 0 ) -#define TracyCMemoryDiscard( name ) ___tracy_emit_memory_discard_callstack( name, 0, TRACY_CALLSTACK ); -#define TracyCSecureAlloc( ptr, size ) ___tracy_emit_memory_alloc_callstack( ptr, size, TRACY_CALLSTACK, 1 ) -#define TracyCSecureFree( ptr ) ___tracy_emit_memory_free_callstack( ptr, TRACY_CALLSTACK, 1 ) -#define TracyCSecureMemoryDiscard( name ) ___tracy_emit_memory_discard_callstack( name, 1, TRACY_CALLSTACK ); +#define TracyCAlloc( ptr, size ) ___tracy_emit_memory_alloc_callstack( ptr, size, TRACY_CALLSTACK ) +#define TracyCFree( ptr ) ___tracy_emit_memory_free_callstack( ptr, TRACY_CALLSTACK ) +#define TracyCMemoryDiscard( name ) ___tracy_emit_memory_discard_callstack( name, TRACY_CALLSTACK ); -#define TracyCAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, TRACY_CALLSTACK, 0, name ) -#define TracyCFreeN( ptr, name ) ___tracy_emit_memory_free_callstack_named( ptr, TRACY_CALLSTACK, 0, name ) -#define TracyCSecureAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, TRACY_CALLSTACK, 1, name ) -#define TracyCSecureFreeN( ptr, name ) ___tracy_emit_memory_free_callstack_named( ptr, TRACY_CALLSTACK, 1, name ) +#define TracyCAllocN( ptr, size, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, TRACY_CALLSTACK, name ) +#define TracyCFreeN( ptr, name ) ___tracy_emit_memory_free_callstack_named( ptr, TRACY_CALLSTACK, name ) #define TracyCMessage( txt, size ) ___tracy_emit_logString( TracyMessageSeverityInfo, 0, TRACY_CALLSTACK, size, txt ) #define TracyCMessageL( txt ) ___tracy_emit_logStringL( TracyMessageSeverityInfo, 0, TRACY_CALLSTACK, txt ) @@ -357,17 +342,12 @@ TRACY_API void ___tracy_emit_message_appinfo( const char* txt, size_t size ); #define TracyCZoneCS( ctx, color, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { NULL, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); #define TracyCZoneNCS( ctx, name, color, depth, active ) static const struct ___tracy_source_location_data TracyConcat(__tracy_source_location,TracyLine) = { name, __func__, TracyFile, (uint32_t)TracyLine, color }; TracyCZoneCtx ctx = ___tracy_emit_zone_begin_callstack( &TracyConcat(__tracy_source_location,TracyLine), depth, active ); -#define TracyCAllocS( ptr, size, depth ) ___tracy_emit_memory_alloc_callstack( ptr, size, depth, 0 ) -#define TracyCFreeS( ptr, depth ) ___tracy_emit_memory_free_callstack( ptr, depth, 0 ) -#define TracyCMemoryDiscardS( name, depth ) ___tracy_emit_memory_discard_callstack( name, 0, depth ) -#define TracyCSecureAllocS( ptr, size, depth ) ___tracy_emit_memory_alloc_callstack( ptr, size, depth, 1 ) -#define TracyCSecureFreeS( ptr, depth ) ___tracy_emit_memory_free_callstack( ptr, depth, 1 ) -#define TracyCSecureMemoryDiscardS( name, depth ) ___tracy_emit_memory_discard_callstack( name, 1, depth ) +#define TracyCAllocS( ptr, size, depth ) ___tracy_emit_memory_alloc_callstack( ptr, size, depth ) +#define TracyCFreeS( ptr, depth ) ___tracy_emit_memory_free_callstack( ptr, depth ) +#define TracyCMemoryDiscardS( name, depth ) ___tracy_emit_memory_discard_callstack( name, depth ) -#define TracyCAllocNS( ptr, size, depth, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, depth, 0, name ) -#define TracyCFreeNS( ptr, depth, name ) ___tracy_emit_memory_free_callstack_named( ptr, depth, 0, name ) -#define TracyCSecureAllocNS( ptr, size, depth, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, depth, 1, name ) -#define TracyCSecureFreeNS( ptr, depth, name ) ___tracy_emit_memory_free_callstack_named( ptr, depth, 1, name ) +#define TracyCAllocNS( ptr, size, depth, name ) ___tracy_emit_memory_alloc_callstack_named( ptr, size, depth, name ) +#define TracyCFreeNS( ptr, depth, name ) ___tracy_emit_memory_free_callstack_named( ptr, depth, name ) #define TracyCMessageS( txt, size, depth ) ___tracy_emit_logString( TracyMessageSeverityInfo, 0, depth, size, txt ) #define TracyCMessageLS( txt, depth ) ___tracy_emit_logStringL( TracyMessageSeverityInfo, 0, depth, txt )