diff --git a/manual/tracy.tex b/manual/tracy.tex index ce1a75ac..f478ee33 100644 --- a/manual/tracy.tex +++ b/manual/tracy.tex @@ -1491,6 +1491,17 @@ Fast navigation in large data sets and correlating zones with what was happening If you want to include color coding of the messages (for example to make critical messages easily visible), you can use \texttt{TracyMessageC(text, size, color)} or \texttt{TracyMessageLC(text, color)} macros. +Messages can also have different severity levels: \texttt{Trace}, \texttt{Debug}, \texttt{Info}, \texttt{Warning}, \texttt{Error} or \texttt{Fatal}. +The previous macros will log messages with the severity "Info". To log a message with a different severity, you may use the \texttt{TracyLogString} macro that regroups all the functionalities from the previous macros. We recommend writing your own macros, wrapping the different severities for easier use. You may provide a color of 0 if you do not want to set a color for this message. + +Examples: +\begin{lstlisting} +std::string dynStr = "Trace using a dynamic string, blue color, no callstack"; +TracyLogString( tracy::MessageSeverity::Trace, 0xFF, 0, dynStr.size(), dynStr.c_str() ); +TracyLogString( tracy::MessageSeverity::Warning, 0, TRACY_CALLSTACK, "Warning using a string litteral, no color, capturing the callstack to a depth of TRACY_CALLSTACK" ); +\end{lstlisting} + + \subsubsection{Application information} \label{appinfo} diff --git a/public/client/TracyProfiler.cpp b/public/client/TracyProfiler.cpp index 39022aa0..0535644d 100644 --- a/public/client/TracyProfiler.cpp +++ b/public/client/TracyProfiler.cpp @@ -2014,7 +2014,7 @@ void Profiler::Worker() switch( (QueueType)idx ) { case QueueType::MessageAppInfo: - ptr = MemRead( &item.messageFat.text ); + ptr = MemRead( &item.messageFat.textAndMetadata ).GetAddress(); size = MemRead( &item.messageFat.size ); SendSingleString( (const char*)ptr, size ); break; @@ -2328,7 +2328,7 @@ static void FreeAssociatedMemory( const QueueItem& item ) break; case QueueType::MessageColor: case QueueType::MessageColorCallstack: - ptr = MemRead( &item.messageColorFat.text ); + ptr = MemRead( &item.messageColorFat.textAndMetadata ).GetAddress(); tracy_free( (void*)ptr ); break; case QueueType::Message: @@ -2336,7 +2336,7 @@ static void FreeAssociatedMemory( const QueueItem& item ) #ifndef TRACY_ON_DEMAND case QueueType::MessageAppInfo: #endif - ptr = MemRead( &item.messageFat.text ); + ptr = MemRead( &item.messageFat.textAndMetadata ).GetAddress(); tracy_free( (void*)ptr ); break; case QueueType::ZoneBeginAllocSrcLoc: @@ -2505,20 +2505,42 @@ Profiler::DequeueStatus Profiler::Dequeue( moodycamel::ConsumerToken& token ) break; case QueueType::Message: case QueueType::MessageCallstack: - ptr = MemRead( &item->messageFat.text ); + { + TaggedUserlandAddress taggedPtr = MemRead( &item->messageFat.textAndMetadata ); + ptr = taggedPtr.GetAddress(); size = MemRead( &item->messageFat.size ); SendSingleString( (const char*)ptr, size ); tracy_free_fast( (void*)ptr ); - break; + + const MessageMetadata metadata = (MessageMetadata)taggedPtr.GetTag(); + QueueItem itemWithMetadata; + MemWrite( &itemWithMetadata.hdr, item->hdr ); + MemWrite( &itemWithMetadata.messageMetadata, item->message ); + MemWrite( &itemWithMetadata.messageMetadata.metadata, metadata ); + AppendData( &itemWithMetadata, QueueDataSize[idx] ); + ++item; + continue; // Next item since we sent it manually + } case QueueType::MessageColor: case QueueType::MessageColorCallstack: - ptr = MemRead( &item->messageColorFat.text ); + { + TaggedUserlandAddress taggedPtr = MemRead( &item->messageColorFat.textAndMetadata ); + ptr = taggedPtr.GetAddress(); size = MemRead( &item->messageColorFat.size ); SendSingleString( (const char*)ptr, size ); tracy_free_fast( (void*)ptr ); - break; + + const MessageMetadata metadata = (MessageMetadata)taggedPtr.GetTag(); + QueueItem itemWithMetadata; + MemWrite( &itemWithMetadata.hdr, item->hdr ); + MemWrite( &itemWithMetadata.messageColorMetadata, item->messageColor ); + MemWrite( &itemWithMetadata.messageColorMetadata.metadata, metadata ); + AppendData( &itemWithMetadata, QueueDataSize[idx] ); + ++item; + continue; // Next item since we sent it manually + } case QueueType::MessageAppInfo: - ptr = MemRead( &item->messageFat.text ); + ptr = MemRead( &item->messageFat.textAndMetadata ).GetAddress(); size = MemRead( &item->messageFat.size ); SendSingleString( (const char*)ptr, size ); #ifndef TRACY_ON_DEMAND @@ -3053,7 +3075,7 @@ Profiler::DequeueStatus Profiler::DequeueSerial() case QueueType::MessageCallstack: { ThreadCtxCheckSerial( messageFatThread ); - ptr = MemRead( &item->messageFat.text ); + ptr = MemRead( &item->messageFat.textAndMetadata ).GetAddress(); uint16_t size = MemRead( &item->messageFat.size ); SendSingleString( (const char*)ptr, size ); tracy_free_fast( (void*)ptr ); @@ -3063,7 +3085,7 @@ Profiler::DequeueStatus Profiler::DequeueSerial() case QueueType::MessageColorCallstack: { ThreadCtxCheckSerial( messageColorFatThread ); - ptr = MemRead( &item->messageColorFat.text ); + ptr = MemRead( &item->messageColorFat.textAndMetadata ).GetAddress(); uint16_t size = MemRead( &item->messageColorFat.size ); SendSingleString( (const char*)ptr, size ); tracy_free_fast( (void*)ptr ); diff --git a/public/client/TracyProfiler.hpp b/public/client/TracyProfiler.hpp index 26a22ec2..3ee7dc53 100644 --- a/public/client/TracyProfiler.hpp +++ b/public/client/TracyProfiler.hpp @@ -406,7 +406,7 @@ public: TracyLfqCommit; } - static tracy_force_inline void Message( const char* txt, size_t size, int32_t callstack_depth ) + static tracy_force_inline void Message( MessageSourceType source, MessageSeverity severity, const char* txt, size_t size, int32_t callstack_depth ) { assert( size < (std::numeric_limits::max)() ); #ifdef TRACY_ON_DEMAND @@ -419,15 +419,20 @@ public: auto ptr = (char*)tracy_malloc( size ); memcpy( ptr, txt, size ); + TaggedUserlandAddress taggedPtr{ (uint64_t)ptr, MakeMessageMetadata( source, severity ) }; TracyQueuePrepare( callstack_depth == 0 ? QueueType::Message : QueueType::MessageCallstack ); MemWrite( &item->messageFat.time, GetTime() ); - MemWrite( &item->messageFat.text, (uint64_t)ptr ); + MemWrite( &item->messageFat.textAndMetadata, taggedPtr ); MemWrite( &item->messageFat.size, (uint16_t)size ); TracyQueueCommit( messageFatThread ); } + static tracy_force_inline void Message(const char* txt, size_t size, int32_t callstack_depth) + { + Message(tracy::MessageSourceType::User, tracy::MessageSeverity::Info, txt, size, callstack_depth); + } - static tracy_force_inline void Message( const char* txt, int32_t callstack_depth ) + static tracy_force_inline void Message( MessageSourceType source, MessageSeverity severity, const char* txt, int32_t callstack_depth ) { #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; @@ -436,14 +441,20 @@ public: { tracy::GetProfiler().SendCallstack( callstack_depth ); } + + TaggedUserlandAddress taggedPtr{ (uint64_t)txt, MakeMessageMetadata( source, severity ) }; TracyQueuePrepare( callstack_depth == 0 ? QueueType::MessageLiteral : QueueType::MessageLiteralCallstack ); MemWrite( &item->messageLiteral.time, GetTime() ); - MemWrite( &item->messageLiteral.text, (uint64_t)txt ); + MemWrite( &item->messageLiteral.textAndMetadata, taggedPtr ); TracyQueueCommit( messageLiteralThread ); } + static tracy_force_inline void Message( const char* txt, int32_t callstack_depth ) + { + Message( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, txt, callstack_depth ); + } - static tracy_force_inline void MessageColor( const char* txt, size_t size, uint32_t color, int32_t callstack_depth ) + static tracy_force_inline void MessageColor( MessageSourceType source, MessageSeverity severity, const char* txt, size_t size, uint32_t color, int32_t callstack_depth ) { assert( size < (std::numeric_limits::max)() ); #ifdef TRACY_ON_DEMAND @@ -456,18 +467,23 @@ public: auto ptr = (char*)tracy_malloc( size ); memcpy( ptr, txt, size ); + TaggedUserlandAddress taggedPtr{ (uint64_t)ptr, MakeMessageMetadata( source, severity ) }; TracyQueuePrepare( callstack_depth == 0 ? QueueType::MessageColor : QueueType::MessageColorCallstack ); MemWrite( &item->messageColorFat.time, GetTime() ); - MemWrite( &item->messageColorFat.text, (uint64_t)ptr ); + MemWrite( &item->messageColorFat.textAndMetadata, taggedPtr ); MemWrite( &item->messageColorFat.b, uint8_t( ( color ) & 0xFF ) ); MemWrite( &item->messageColorFat.g, uint8_t( ( color >> 8 ) & 0xFF ) ); MemWrite( &item->messageColorFat.r, uint8_t( ( color >> 16 ) & 0xFF ) ); MemWrite( &item->messageColorFat.size, (uint16_t)size ); TracyQueueCommit( messageColorFatThread ); } + static tracy_force_inline void MessageColor( const char* txt, size_t size, uint32_t color, int32_t callstack_depth ) + { + MessageColor( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, txt, size, color, callstack_depth ); + } - static tracy_force_inline void MessageColor( const char* txt, uint32_t color, int32_t callstack_depth ) + static tracy_force_inline void MessageColor( MessageSourceType source, MessageSeverity severity, const char* txt, uint32_t color, int32_t callstack_depth ) { #ifdef TRACY_ON_DEMAND if( !GetProfiler().IsConnected() ) return; @@ -476,24 +492,44 @@ public: { tracy::GetProfiler().SendCallstack( callstack_depth ); } + TaggedUserlandAddress taggedPtr{ (uint64_t)txt, MakeMessageMetadata( source, severity ) }; TracyQueuePrepare( callstack_depth == 0 ? QueueType::MessageLiteralColor : QueueType::MessageLiteralColorCallstack ); MemWrite( &item->messageColorLiteral.time, GetTime() ); - MemWrite( &item->messageColorLiteral.text, (uint64_t)txt ); + MemWrite( &item->messageColorLiteral.textAndMetadata, taggedPtr ); MemWrite( &item->messageColorLiteral.b, uint8_t( ( color ) & 0xFF ) ); MemWrite( &item->messageColorLiteral.g, uint8_t( ( color >> 8 ) & 0xFF ) ); MemWrite( &item->messageColorLiteral.r, uint8_t( ( color >> 16 ) & 0xFF ) ); TracyQueueCommit( messageColorLiteralThread ); } + static tracy_force_inline void MessageColor( const char* txt, uint32_t color, int32_t callstack_depth ) + { + MessageColor( tracy::MessageSourceType::User, tracy::MessageSeverity::Info, txt, color, callstack_depth ); + } + + static tracy_force_inline void LogString( MessageSourceType source, MessageSeverity severity, uint32_t color, int32_t callstack_depth, const char* txt ) + { + if( color != 0 ) MessageColor( source, severity, txt, color, callstack_depth ); + else Message( source, severity, txt, callstack_depth ); + } + + static tracy_force_inline void LogString( MessageSourceType source, MessageSeverity severity, uint32_t color, int32_t callstack_depth, size_t txtLength, const char* txt ) + { + if( color != 0 ) MessageColor( source, severity, txt, txtLength, color, callstack_depth ); + else Message( source, severity, txt, txtLength, callstack_depth ); + } + static tracy_force_inline void MessageAppInfo( const char* txt, size_t size ) { assert( size < (std::numeric_limits::max)() ); auto ptr = (char*)tracy_malloc( size ); memcpy( ptr, txt, size ); + TaggedUserlandAddress taggedPtr{ (uint64_t)txt, MakeMessageMetadata( MessageSourceType::User, MessageSeverity::Info ) }; + TracyLfqPrepare( QueueType::MessageAppInfo ); MemWrite( &item->messageFat.time, GetTime() ); - MemWrite( &item->messageFat.text, (uint64_t)ptr ); + MemWrite( &item->messageFat.textAndMetadata, taggedPtr ); MemWrite( &item->messageFat.size, (uint16_t)size ); #ifdef TRACY_ON_DEMAND diff --git a/public/common/TracyProtocol.hpp b/public/common/TracyProtocol.hpp index 8174d932..a354b057 100644 --- a/public/common/TracyProtocol.hpp +++ b/public/common/TracyProtocol.hpp @@ -9,7 +9,7 @@ namespace tracy constexpr unsigned Lz4CompressBound( unsigned isize ) { return isize + ( isize / 255 ) + 16; } -enum : uint32_t { ProtocolVersion = 76 }; +enum : uint32_t { ProtocolVersion = 77 }; enum : uint16_t { BroadcastVersion = 3 }; using lz4sz_t = uint32_t; diff --git a/public/common/TracyQueue.hpp b/public/common/TracyQueue.hpp index 765c83c7..dcc1919b 100644 --- a/public/common/TracyQueue.hpp +++ b/public/common/TracyQueue.hpp @@ -3,6 +3,7 @@ #include #include +#include "TracyTaggedUserlandAddress.hpp" namespace tracy { @@ -343,6 +344,47 @@ struct QueuePlotDataDouble : public QueuePlotDataBase double val; }; +using MessageMetadata = uint8_t; + +enum class MessageSourceType : MessageMetadata +{ + User, + Tracy, + COUNT +}; + +enum class MessageSeverity : MessageMetadata +{ + Trace, // Broadly track variable states and events in the software program. + Debug, // Describes variable states and details about specific internal events in the software, that are useful for investigations. + Info, // Describes normal events, which inform on the expected progress and state of your software. + Warning, // Describes potentially dangerous situations caused by unexpected events and states. + Error, // Describes the occurance of unexpected behavior. Does not interrupt the execution of the software. + Fatal, // Describes a critical event that will lead to a software failure/crash. + COUNT +}; + +inline MessageMetadata MakeMessageMetadata(MessageSourceType source, MessageSeverity severity) +{ + static_assert( (MessageMetadata)MessageSourceType::COUNT < ( 1 << 4 ), "We use 4 bits for the messages source." ); + static_assert( (MessageMetadata)MessageSeverity::COUNT < ( 1 << 4 ), "We use 4 bits for the messages severity." ); + return ( (MessageMetadata)severity ) << 4 | (MessageMetadata)source; +} + +inline MessageSourceType MessageSourceFromMetadata(MessageMetadata metadata) +{ + assert( ( metadata & 0x0F ) < (MessageMetadata)MessageSourceType::COUNT ); + return (MessageSourceType)( metadata & 0x0F ); +} + +inline MessageSeverity MessageSeverityFromMetadata(MessageMetadata metadata) +{ + assert( ( ( metadata & 0xF0 ) >> 4 ) < (MessageMetadata)MessageSeverity::COUNT ); + return (MessageSeverity)( ( metadata & 0xF0 ) >> 4 ); +} + +// QueueMessage*Metadata and QueMessageLiteral* are the only structures sent over the wire +// All other variants are used only internally to dispatch from the thread to the profiler and interpreted by Profiler::Dequeue struct QueueMessage { int64_t time; @@ -355,9 +397,19 @@ struct QueueMessageColor : public QueueMessage uint8_t r; }; +struct QueueMessageMetadata : public QueueMessage +{ + MessageMetadata metadata; +}; + +struct QueueMessageColorMetadata : public QueueMessageColor +{ + MessageMetadata metadata; +}; + struct QueueMessageLiteral : public QueueMessage { - uint64_t text; // ptr + TaggedUserlandAddress textAndMetadata; // ptr + log level/channels }; struct QueueMessageLiteralThread : public QueueMessageLiteral @@ -367,7 +419,7 @@ struct QueueMessageLiteralThread : public QueueMessageLiteral struct QueueMessageColorLiteral : public QueueMessageColor { - uint64_t text; // ptr + TaggedUserlandAddress textAndMetadata; // ptr + log level/channels }; struct QueueMessageColorLiteralThread : public QueueMessageColorLiteral @@ -377,7 +429,7 @@ struct QueueMessageColorLiteralThread : public QueueMessageColorLiteral struct QueueMessageFat : public QueueMessage { - uint64_t text; // ptr + TaggedUserlandAddress textAndMetadata; // ptr + log level/channels uint16_t size; }; @@ -388,7 +440,7 @@ struct QueueMessageFatThread : public QueueMessageFat struct QueueMessageColorFat : public QueueMessageColor { - uint64_t text; // ptr + TaggedUserlandAddress textAndMetadata; // ptr + log level/channels uint16_t size; }; @@ -762,7 +814,9 @@ struct QueueItem QueuePlotDataFloat plotDataFloat; QueuePlotDataDouble plotDataDouble; QueueMessage message; + QueueMessageMetadata messageMetadata; QueueMessageColor messageColor; + QueueMessageColorMetadata messageColorMetadata; QueueMessageLiteral messageLiteral; QueueMessageLiteralThread messageLiteralThread; QueueMessageColorLiteral messageColorLiteral; @@ -826,10 +880,10 @@ enum { QueueItemSize = sizeof( QueueItem ) }; static constexpr size_t QueueDataSize[] = { sizeof( QueueHeader ), // zone text sizeof( QueueHeader ), // zone name - sizeof( QueueHeader ) + sizeof( QueueMessage ), - sizeof( QueueHeader ) + sizeof( QueueMessageColor ), - sizeof( QueueHeader ) + sizeof( QueueMessage ), // callstack - sizeof( QueueHeader ) + sizeof( QueueMessageColor ), // callstack + sizeof( QueueHeader ) + sizeof( QueueMessageMetadata ), // Message + sizeof( QueueHeader ) + sizeof( QueueMessageColorMetadata ),// MessageColor + sizeof( QueueHeader ) + sizeof( QueueMessageMetadata ), // MessageCallstack + sizeof( QueueHeader ) + sizeof( QueueMessageColorMetadata ),// MessageColorCallstack sizeof( QueueHeader ) + sizeof( QueueMessage ), // app info sizeof( QueueHeader ) + sizeof( QueueZoneBeginLean ), // allocated source location sizeof( QueueHeader ) + sizeof( QueueZoneBeginLean ), // allocated source location, callstack diff --git a/public/tracy/Tracy.hpp b/public/tracy/Tracy.hpp index 84813969..619f3a13 100644 --- a/public/tracy/Tracy.hpp +++ b/public/tracy/Tracy.hpp @@ -214,6 +214,8 @@ #define TracyAppInfo( txt, size ) tracy::Profiler::MessageAppInfo( txt, size ) +#define TracyLogString( severity, color, depth, ... ) tracy::Profiler::LogString( tracy::MessageSourceType::User, severity, color, depth, __VA_ARGS__ ) + #define TracyMessage( txt, size ) tracy::Profiler::Message( txt, size, TRACY_CALLSTACK ) #define TracyMessageL( txt ) tracy::Profiler::Message( txt, TRACY_CALLSTACK ) #define TracyMessageC( txt, size, color ) tracy::Profiler::MessageColor( txt, size, color, TRACY_CALLSTACK ) diff --git a/server/TracyWorker.cpp b/server/TracyWorker.cpp index d94a1ab5..bb9187f1 100644 --- a/server/TracyWorker.cpp +++ b/server/TracyWorker.cpp @@ -4578,25 +4578,25 @@ bool Worker::Process( const QueueItem& ev ) ProcessPlotConfig( ev.plotConfig ); break; case QueueType::Message: - ProcessMessage( ev.message ); + ProcessMessage( ev.messageMetadata ); break; case QueueType::MessageLiteral: ProcessMessageLiteral( ev.messageLiteral ); break; case QueueType::MessageColor: - ProcessMessageColor( ev.messageColor ); + ProcessMessageColor( ev.messageColorMetadata ); break; case QueueType::MessageLiteralColor: ProcessMessageLiteralColor( ev.messageColorLiteral ); break; case QueueType::MessageCallstack: - ProcessMessageCallstack( ev.message ); + ProcessMessageCallstack( ev.messageMetadata ); break; case QueueType::MessageLiteralCallstack: ProcessMessageLiteralCallstack( ev.messageLiteral ); break; case QueueType::MessageColorCallstack: - ProcessMessageColorCallstack( ev.messageColor ); + ProcessMessageColorCallstack( ev.messageColorMetadata ); break; case QueueType::MessageLiteralColorCallstack: ProcessMessageLiteralColorCallstack( ev.messageColorLiteral ); @@ -5613,7 +5613,7 @@ void Worker::ProcessPlotConfig( const QueuePlotConfig& ev ) plot->color = ev.color & 0xFFFFFF; } -void Worker::ProcessMessage( const QueueMessage& ev ) +void Worker::ProcessMessage( const QueueMessageMetadata& ev ) { auto td = GetCurrentThreadData(); auto msg = m_slab.Alloc(); @@ -5630,11 +5630,11 @@ void Worker::ProcessMessage( const QueueMessage& ev ) void Worker::ProcessMessageLiteral( const QueueMessageLiteral& ev ) { auto td = GetCurrentThreadData(); - CheckString( ev.text ); + CheckString( ev.textAndMetadata.GetAddress() ); auto msg = m_slab.Alloc(); const auto time = TscTime( ev.time ); msg->time = time; - msg->ref = StringRef( StringRef::Type::Ptr, ev.text ); + msg->ref = StringRef( StringRef::Type::Ptr, ev.textAndMetadata.GetAddress() ); msg->thread = CompressThread( td->id ); msg->color = 0xFFFFFFFF; msg->callstack.SetVal( 0 ); @@ -5642,7 +5642,7 @@ void Worker::ProcessMessageLiteral( const QueueMessageLiteral& ev ) InsertMessageData( msg ); } -void Worker::ProcessMessageColor( const QueueMessageColor& ev ) +void Worker::ProcessMessageColor( const QueueMessageColorMetadata& ev ) { auto td = GetCurrentThreadData(); auto msg = m_slab.Alloc(); @@ -5659,11 +5659,11 @@ void Worker::ProcessMessageColor( const QueueMessageColor& ev ) void Worker::ProcessMessageLiteralColor( const QueueMessageColorLiteral& ev ) { auto td = GetCurrentThreadData(); - CheckString( ev.text ); + CheckString( ev.textAndMetadata.GetAddress() ); auto msg = m_slab.Alloc(); const auto time = TscTime( ev.time ); msg->time = time; - msg->ref = StringRef( StringRef::Type::Ptr, ev.text ); + msg->ref = StringRef( StringRef::Type::Ptr, ev.textAndMetadata.GetAddress() ); msg->thread = CompressThread( td->id ); msg->color = 0xFF000000 | ( ev.b << 16 ) | ( ev.g << 8 ) | ev.r; msg->callstack.SetVal( 0 ); @@ -5671,7 +5671,7 @@ void Worker::ProcessMessageLiteralColor( const QueueMessageColorLiteral& ev ) InsertMessageData( msg ); } -void Worker::ProcessMessageCallstack( const QueueMessage& ev ) +void Worker::ProcessMessageCallstack( const QueueMessageMetadata& ev ) { auto td = GetCurrentThreadData(); ProcessMessage( ev ); @@ -5691,7 +5691,7 @@ void Worker::ProcessMessageLiteralCallstack( const QueueMessageLiteral& ev ) it->second = 0; } -void Worker::ProcessMessageColorCallstack( const QueueMessageColor& ev ) +void Worker::ProcessMessageColorCallstack( const QueueMessageColorMetadata& ev ) { auto td = GetCurrentThreadData(); ProcessMessageColor( ev ); diff --git a/server/TracyWorker.hpp b/server/TracyWorker.hpp index c76cd7cf..c7025573 100644 --- a/server/TracyWorker.hpp +++ b/server/TracyWorker.hpp @@ -749,13 +749,13 @@ private: tracy_force_inline void ProcessPlotDataFloat( const QueuePlotDataFloat& ev ); tracy_force_inline void ProcessPlotDataDouble( const QueuePlotDataDouble& ev ); tracy_force_inline void ProcessPlotConfig( const QueuePlotConfig& ev ); - tracy_force_inline void ProcessMessage( const QueueMessage& ev ); + tracy_force_inline void ProcessMessage( const QueueMessageMetadata& ev ); tracy_force_inline void ProcessMessageLiteral( const QueueMessageLiteral& ev ); - tracy_force_inline void ProcessMessageColor( const QueueMessageColor& ev ); + tracy_force_inline void ProcessMessageColor( const QueueMessageColorMetadata& ev ); tracy_force_inline void ProcessMessageLiteralColor( const QueueMessageColorLiteral& ev ); - tracy_force_inline void ProcessMessageCallstack( const QueueMessage& ev ); + tracy_force_inline void ProcessMessageCallstack( const QueueMessageMetadata& ev ); tracy_force_inline void ProcessMessageLiteralCallstack( const QueueMessageLiteral& ev ); - tracy_force_inline void ProcessMessageColorCallstack( const QueueMessageColor& ev ); + tracy_force_inline void ProcessMessageColorCallstack( const QueueMessageColorMetadata& ev ); tracy_force_inline void ProcessMessageLiteralColorCallstack( const QueueMessageColorLiteral& ev ); tracy_force_inline void ProcessMessageAppInfo( const QueueMessage& ev ); tracy_force_inline void ProcessGpuNewContext( const QueueGpuNewContext& ev );