Merge pull request #957 from foxtran/feature/merge-calls-callstack

Simplify API by decreasing a number of entry points

public/client/TracyCallstack.hpp

@@ -9,6 +9,7 @@
 
 namespace tracy
 {
+static constexpr bool has_callstack() { return false; }
 static tracy_force_inline void* Callstack( int /*depth*/ ) { return nullptr; }
 }
 
@@ -38,6 +39,8 @@ static tracy_force_inline void* Callstack( int /*depth*/ ) { return nullptr; }
 namespace tracy
 {
 
+static constexpr bool has_callstack() { return true; }
+
 struct CallstackSymbolData
 {
     const char* file;

public/client/TracyProfiler.cpp

@@ -1474,7 +1474,7 @@ Profiler::Profiler()
 #ifndef _WIN32
     pipe(m_pipe);
 #  if defined __APPLE__ || defined BSD
-    // FreeBSD/XNU don't have F_SETPIPE_SZ, so use the default 
+    // FreeBSD/XNU don't have F_SETPIPE_SZ, so use the default
     m_pipeBufSize = 16384;
 #  else
     m_pipeBufSize = (int)(ptrdiff_t)SafeSendBufferSize;
@@ -3161,7 +3161,7 @@ char* Profiler::SafeCopyProlog( const char* data, size_t size )
 void Profiler::SafeCopyEpilog( char* buf )
 {
     if( buf != m_safeSendBuffer ) tracy_free( buf );
-    
+
 #ifndef NDEBUG
     m_inUse.store( false );
 #endif
@@ -4121,7 +4121,7 @@ void Profiler::HandleSymbolCodeQuery( uint64_t symbol, uint32_t size )
     }
     else
     {
-        auto&& lambda = [ this, symbol ]( const char* buf, size_t size ) { 
+        auto&& lambda = [ this, symbol ]( const char* buf, size_t size ) {
             SendLongString( symbol, buf, size, QueueType::SymbolCode );
         };
 
@@ -4295,13 +4295,17 @@ TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_callstack( const struct ___trac
         TracyQueueCommitC( zoneValidationThread );
     }
 #endif
-    tracy::GetProfiler().SendCallstack( depth );
+    auto zoneQueue = tracy::QueueType::ZoneBegin;
+    if( depth > 0 && tracy::has_callstack() )
     {
-        TracyQueuePrepareC( tracy::QueueType::ZoneBeginCallstack );
-        tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
-        tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
-        TracyQueueCommitC( zoneBeginThread );
+        tracy::GetProfiler().SendCallstack( depth );
+        zoneQueue = tracy::QueueType::ZoneBeginCallstack;
     }
+    TracyQueuePrepareC( zoneQueue );
+    tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
+    tracy::MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
+    TracyQueueCommitC( zoneBeginThread );
+
     return ctx;
 }
 
@@ -4360,13 +4364,17 @@ TRACY_API TracyCZoneCtx ___tracy_emit_zone_begin_alloc_callstack( uint64_t srclo
         TracyQueueCommitC( zoneValidationThread );
     }
 #endif
-    tracy::GetProfiler().SendCallstack( depth );
+    auto zoneQueue = tracy::QueueType::ZoneBeginAllocSrcLoc;
+    if( depth > 0 && tracy::has_callstack() )
     {
-        TracyQueuePrepareC( tracy::QueueType::ZoneBeginAllocSrcLocCallstack );
-        tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
-        tracy::MemWrite( &item->zoneBegin.srcloc, srcloc );
-        TracyQueueCommitC( zoneBeginThread );
+        tracy::GetProfiler().SendCallstack( depth );
+        zoneQueue = tracy::QueueType::ZoneBeginAllocSrcLocCallstack;
     }
+    TracyQueuePrepareC( zoneQueue );
+    tracy::MemWrite( &item->zoneBegin.time, tracy::Profiler::GetTime() );
+    tracy::MemWrite( &item->zoneBegin.srcloc, srcloc );
+    TracyQueueCommitC( zoneBeginThread );
+
     return ctx;
 }
 
@@ -4465,15 +4473,65 @@ 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, int secure ) { tracy::Profiler::MemAlloc( ptr, size, secure != 0 ); }
-TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth, int secure ) { tracy::Profiler::MemAllocCallstack( ptr, size, depth, secure != 0 ); }
+TRACY_API void ___tracy_emit_memory_alloc_callstack( const void* ptr, size_t size, int depth, int secure )
+{
+    if( depth > 0 && tracy::has_callstack() )
+    {
+        tracy::Profiler::MemAllocCallstack( ptr, size, depth, secure != 0 );
+    }
+    else
+    {
+        tracy::Profiler::MemAlloc( ptr, size, secure != 0 );
+    }
+}
 TRACY_API void ___tracy_emit_memory_free( const void* ptr, int secure ) { tracy::Profiler::MemFree( ptr, secure != 0 ); }
-TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth, int secure ) { tracy::Profiler::MemFreeCallstack( ptr, depth, secure != 0 ); }
+TRACY_API void ___tracy_emit_memory_free_callstack( const void* ptr, int depth, int secure )
+{
+    if( depth > 0 && tracy::has_callstack() )
+    {
+        tracy::Profiler::MemFreeCallstack( ptr, depth, secure != 0 );
+    }
+    else
+    {
+        tracy::Profiler::MemFree( ptr, secure != 0 );
+    }
+}
 TRACY_API void ___tracy_emit_memory_discard( const char* name, int secure ) { tracy::Profiler::MemDiscard( name, secure != 0 ); }
-TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int secure, int depth ) { tracy::Profiler::MemDiscardCallstack( name, secure != 0, depth ); }
+TRACY_API void ___tracy_emit_memory_discard_callstack( const char* name, int secure, int depth )
+{
+    if( depth > 0 && tracy::has_callstack() )
+    {
+        tracy::Profiler::MemDiscardCallstack( name, secure != 0, depth );
+    }
+    else
+    {
+        tracy::Profiler::MemDiscard( name, secure != 0 );
+    }
+}
 TRACY_API void ___tracy_emit_memory_alloc_named( const void* ptr, size_t size, int 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, int depth, int secure, const char* name ) { tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, secure != 0, name ); }
+TRACY_API void ___tracy_emit_memory_alloc_callstack_named( const void* ptr, size_t size, int depth, int secure, const char* name )
+{
+    if( depth > 0 && tracy::has_callstack() )
+    {
+        tracy::Profiler::MemAllocCallstackNamed( ptr, size, depth, secure != 0, name );
+    }
+    else
+    {
+        tracy::Profiler::MemAllocNamed( ptr, size, secure != 0, name );
+    }
+}
 TRACY_API void ___tracy_emit_memory_free_named( const void* ptr, int secure, const char* name ) { tracy::Profiler::MemFreeNamed( ptr, secure != 0, name ); }
-TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int depth, int secure, const char* name ) { tracy::Profiler::MemFreeCallstackNamed( ptr, depth, secure != 0, name ); }
+TRACY_API void ___tracy_emit_memory_free_callstack_named( const void* ptr, int depth, int secure, const char* name )
+{
+    if( depth > 0 && tracy::has_callstack() )
+    {
+        tracy::Profiler::MemFreeCallstackNamed( ptr, depth, secure != 0, name );
+    }
+    else
+    {
+        tracy::Profiler::MemFreeNamed( ptr, secure != 0, name );
+    }
+}
 TRACY_API void ___tracy_emit_frame_mark( const char* name ) { tracy::Profiler::SendFrameMark( name ); }
 TRACY_API void ___tracy_emit_frame_mark_start( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgStart ); }
 TRACY_API void ___tracy_emit_frame_mark_end( const char* name ) { tracy::Profiler::SendFrameMark( name, tracy::QueueType::FrameMarkMsgEnd ); }

public/client/TracyProfiler.hpp

@@ -513,23 +513,25 @@ public:
     static tracy_force_inline void MemAllocCallstack( const void* ptr, size_t size, int depth, bool secure )
     {
         if( secure && !ProfilerAvailable() ) return;
-#ifdef TRACY_HAS_CALLSTACK
-        auto& profiler = GetProfiler();
+        if( depth > 0 && has_callstack() )
+        {
+            auto& profiler = GetProfiler();
 #  ifdef TRACY_ON_DEMAND
-        if( !profiler.IsConnected() ) return;
+            if( !profiler.IsConnected() ) return;
 #  endif
-        const auto thread = GetThreadHandle();
+            const auto thread = GetThreadHandle();
 
-        auto callstack = Callstack( depth );
+            auto callstack = Callstack( depth );
 
-        profiler.m_serialLock.lock();
-        SendCallstackSerial( callstack );
-        SendMemAlloc( QueueType::MemAllocCallstack, thread, ptr, size );
-        profiler.m_serialLock.unlock();
-#else
-        static_cast<void>(depth); // unused
-        MemAlloc( ptr, size, secure );
-#endif
+            profiler.m_serialLock.lock();
+            SendCallstackSerial( callstack );
+            SendMemAlloc( QueueType::MemAllocCallstack, thread, ptr, size );
+            profiler.m_serialLock.unlock();
+        }
+        else
+        {
+            MemAlloc( ptr, size, secure );
+        }
     }
 
     static tracy_force_inline void MemFreeCallstack( const void* ptr, int depth, bool secure )
@@ -540,23 +542,25 @@ public:
             MemFree( ptr, secure );
             return;
         }
-#ifdef TRACY_HAS_CALLSTACK
-        auto& profiler = GetProfiler();
+        if( depth > 0 && has_callstack() )
+        {
+            auto& profiler = GetProfiler();
 #  ifdef TRACY_ON_DEMAND
-        if( !profiler.IsConnected() ) return;
+            if( !profiler.IsConnected() ) return;
 #  endif
-        const auto thread = GetThreadHandle();
+            const auto thread = GetThreadHandle();
 
-        auto callstack = Callstack( depth );
+            auto callstack = Callstack( depth );
 
-        profiler.m_serialLock.lock();
-        SendCallstackSerial( callstack );
-        SendMemFree( QueueType::MemFreeCallstack, thread, ptr );
-        profiler.m_serialLock.unlock();
-#else
-        static_cast<void>(depth); // unused
-        MemFree( ptr, secure );
-#endif
+            profiler.m_serialLock.lock();
+            SendCallstackSerial( callstack );
+            SendMemFree( QueueType::MemFreeCallstack, thread, ptr );
+            profiler.m_serialLock.unlock();
+        }
+        else
+        {
+            MemFree( ptr, secure );
+        }
     }
 
     static tracy_force_inline void MemAllocNamed( const void* ptr, size_t size, bool secure, const char* name )
@@ -590,47 +594,51 @@ public:
     static tracy_force_inline void MemAllocCallstackNamed( const void* ptr, size_t size, int depth, bool secure, const char* name )
     {
         if( secure && !ProfilerAvailable() ) return;
-#ifdef TRACY_HAS_CALLSTACK
-        auto& profiler = GetProfiler();
+        if( depth > 0 && has_callstack() )
+        {
+            auto& profiler = GetProfiler();
 #  ifdef TRACY_ON_DEMAND
-        if( !profiler.IsConnected() ) return;
+            if( !profiler.IsConnected() ) return;
 #  endif
-        const auto thread = GetThreadHandle();
+            const auto thread = GetThreadHandle();
 
-        auto callstack = Callstack( depth );
+            auto callstack = Callstack( depth );
 
-        profiler.m_serialLock.lock();
-        SendCallstackSerial( callstack );
-        SendMemName( name );
-        SendMemAlloc( QueueType::MemAllocCallstackNamed, thread, ptr, size );
-        profiler.m_serialLock.unlock();
-#else
-        static_cast<void>(depth); // unused
-        MemAllocNamed( ptr, size, secure, name );
-#endif
+            profiler.m_serialLock.lock();
+            SendCallstackSerial( callstack );
+            SendMemName( name );
+            SendMemAlloc( QueueType::MemAllocCallstackNamed, thread, ptr, size );
+            profiler.m_serialLock.unlock();
+        }
+        else
+        {
+            MemAllocNamed( ptr, size, secure, name );
+        }
     }
 
     static tracy_force_inline void MemFreeCallstackNamed( const void* ptr, int depth, bool secure, const char* name )
     {
         if( secure && !ProfilerAvailable() ) return;
-#ifdef TRACY_HAS_CALLSTACK
-        auto& profiler = GetProfiler();
+        if( depth > 0 && has_callstack() )
+        {
+            auto& profiler = GetProfiler();
 #  ifdef TRACY_ON_DEMAND
-        if( !profiler.IsConnected() ) return;
+            if( !profiler.IsConnected() ) return;
 #  endif
-        const auto thread = GetThreadHandle();
+            const auto thread = GetThreadHandle();
 
-        auto callstack = Callstack( depth );
+            auto callstack = Callstack( depth );
 
-        profiler.m_serialLock.lock();
-        SendCallstackSerial( callstack );
-        SendMemName( name );
-        SendMemFree( QueueType::MemFreeCallstackNamed, thread, ptr );
-        profiler.m_serialLock.unlock();
-#else
-        static_cast<void>(depth); // unused
-        MemFreeNamed( ptr, secure, name );
-#endif
+            profiler.m_serialLock.lock();
+            SendCallstackSerial( callstack );
+            SendMemName( name );
+            SendMemFree( QueueType::MemFreeCallstackNamed, thread, ptr );
+            profiler.m_serialLock.unlock();
+        }
+        else
+        {
+            MemFreeNamed( ptr, secure, name );
+        }
     }
 
     static tracy_force_inline void MemDiscard( const char* name, bool secure )
@@ -649,34 +657,35 @@ public:
     static tracy_force_inline void MemDiscardCallstack( const char* name, bool secure, int depth )
     {
         if( secure && !ProfilerAvailable() ) return;
-#ifdef TRACY_HAS_CALLSTACK
+        if( depth > 0 && has_callstack() )
+        {
 #  ifdef TRACY_ON_DEMAND
-        if( !GetProfiler().IsConnected() ) return;
+            if( !GetProfiler().IsConnected() ) return;
 #  endif
-        const auto thread = GetThreadHandle();
+            const auto thread = GetThreadHandle();
 
-        auto callstack = Callstack( depth );
+            auto callstack = Callstack( depth );
 
-        GetProfiler().m_serialLock.lock();
-        SendCallstackSerial( callstack );
-        SendMemDiscard( QueueType::MemDiscard, thread, name );
-        GetProfiler().m_serialLock.unlock();
-#else
-        static_cast<void>(depth); // unused
-        MemDiscard( name, secure );
-#endif
+            GetProfiler().m_serialLock.lock();
+            SendCallstackSerial( callstack );
+            SendMemDiscard( QueueType::MemDiscard, thread, name );
+            GetProfiler().m_serialLock.unlock();
+        }
+        else
+        {
+            MemDiscard( name, secure );
+        }
     }
 
     static tracy_force_inline void SendCallstack( int depth )
     {
-#ifdef TRACY_HAS_CALLSTACK
-        auto ptr = Callstack( depth );
-        TracyQueuePrepare( QueueType::Callstack );
-        MemWrite( &item->callstackFat.ptr, (uint64_t)ptr );
-        TracyQueueCommit( callstackFatThread );
-#else
-        static_cast<void>(depth); // unused
-#endif
+        if( depth > 0 && has_callstack() )
+        {
+            auto ptr = Callstack( depth );
+            TracyQueuePrepare( QueueType::Callstack );
+            MemWrite( &item->callstackFat.ptr, (uint64_t)ptr );
+            TracyQueueCommit( callstackFatThread );
+        }
     }
 
     static tracy_force_inline void ParameterRegister( ParameterCallback cb, void* data )
@@ -834,7 +843,7 @@ private:
 
     void InstallCrashHandler();
     void RemoveCrashHandler();
-    
+
     void ClearQueues( tracy::moodycamel::ConsumerToken& token );
     void ClearSerial();
     DequeueStatus Dequeue( tracy::moodycamel::ConsumerToken& token );
@@ -911,14 +920,13 @@ private:
 
     static tracy_force_inline void SendCallstackSerial( void* ptr )
     {
-#ifdef TRACY_HAS_CALLSTACK
-        auto item = GetProfiler().m_serialQueue.prepare_next();
-        MemWrite( &item->hdr.type, QueueType::CallstackSerial );
-        MemWrite( &item->callstackFat.ptr, (uint64_t)ptr );
-        GetProfiler().m_serialQueue.commit_next();
-#else
-        static_cast<void>(ptr); // unused
-#endif
+        if( has_callstack() )
+        {
+            auto item = GetProfiler().m_serialQueue.prepare_next();
+            MemWrite( &item->hdr.type, QueueType::CallstackSerial );
+            MemWrite( &item->callstackFat.ptr, (uint64_t)ptr );
+            GetProfiler().m_serialQueue.commit_next();
+        }
     }
 
     static tracy_force_inline void SendMemAlloc( QueueType type, const uint32_t thread, const void* ptr, size_t size )

public/client/TracyScoped.hpp

@@ -10,6 +10,7 @@
 #include "../common/TracyAlign.hpp"
 #include "../common/TracyAlloc.hpp"
 #include "TracyProfiler.hpp"
+#include "TracyCallstack.hpp"
 
 namespace tracy
 {
@@ -22,7 +23,7 @@ public:
     ScopedZone& operator=( const ScopedZone& ) = delete;
     ScopedZone& operator=( ScopedZone&& ) = delete;
 
-    tracy_force_inline ScopedZone( const SourceLocationData* srcloc, bool is_active = true )
+    tracy_force_inline ScopedZone( const SourceLocationData* srcloc, int depth = -1, bool is_active = true )
 #ifdef TRACY_ON_DEMAND
         : m_active( is_active && GetProfiler().IsConnected() )
 #else
@@ -33,13 +34,19 @@ public:
 #ifdef TRACY_ON_DEMAND
         m_connectionId = GetProfiler().ConnectionId();
 #endif
-        TracyQueuePrepare( QueueType::ZoneBegin );
+        auto zoneQueue = QueueType::ZoneBegin;
+        if( depth > 0 && has_callstack() )
+        {
+            GetProfiler().SendCallstack( depth );
+            zoneQueue = QueueType::ZoneBeginCallstack;
+        }
+        TracyQueuePrepare( zoneQueue );
         MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
         MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
         TracyQueueCommit( zoneBeginThread );
     }
 
-    tracy_force_inline ScopedZone( const SourceLocationData* srcloc, int depth, bool is_active = true )
+    tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color, int depth = -1, bool is_active = true )
 #ifdef TRACY_ON_DEMAND
         : m_active( is_active && GetProfiler().IsConnected() )
 #else
@@ -50,49 +57,15 @@ public:
 #ifdef TRACY_ON_DEMAND
         m_connectionId = GetProfiler().ConnectionId();
 #endif
-        GetProfiler().SendCallstack( depth );
-
-        TracyQueuePrepare( QueueType::ZoneBeginCallstack );
-        MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
-        MemWrite( &item->zoneBegin.srcloc, (uint64_t)srcloc );
-        TracyQueueCommit( zoneBeginThread );
-    }
-
-    tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color, bool is_active = true )
-#ifdef TRACY_ON_DEMAND
-        : m_active( is_active && GetProfiler().IsConnected() )
-#else
-        : m_active( is_active )
-#endif
-    {
-        if( !m_active ) return;
-#ifdef TRACY_ON_DEMAND
-        m_connectionId = GetProfiler().ConnectionId();
-#endif
-        TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLoc );
-        const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color );
-        MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
-        MemWrite( &item->zoneBegin.srcloc, srcloc );
-        TracyQueueCommit( zoneBeginThread );
-    }
-
-    tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, bool is_active = true ) : ScopedZone( line, source, sourceSz, function, functionSz, name, nameSz, static_cast<uint32_t>(0), is_active ) {}
-
-    tracy_force_inline ScopedZone( uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, uint32_t color, int depth, bool is_active = true )
-#ifdef TRACY_ON_DEMAND
-        : m_active( is_active && GetProfiler().IsConnected() )
-#else
-        : m_active( is_active )
-#endif
-    {
-        if( !m_active ) return;
-#ifdef TRACY_ON_DEMAND
-        m_connectionId = GetProfiler().ConnectionId();
-#endif
-        GetProfiler().SendCallstack( depth );
-
-        TracyQueuePrepare( QueueType::ZoneBeginAllocSrcLocCallstack );
-        const auto srcloc = Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color );
+        auto zoneQueue = QueueType::ZoneBeginAllocSrcLoc;
+        if( depth > 0 && has_callstack() )
+        {
+            GetProfiler().SendCallstack( depth );
+            zoneQueue = QueueType::ZoneBeginAllocSrcLocCallstack;
+        }
+        TracyQueuePrepare( zoneQueue );
+        const auto srcloc =
+            Profiler::AllocSourceLocation( line, source, sourceSz, function, functionSz, name, nameSz, color );
         MemWrite( &item->zoneBegin.time, Profiler::GetTime() );
         MemWrite( &item->zoneBegin.srcloc, srcloc );
         TracyQueueCommit( zoneBeginThread );