general/tracy
2
0
Fork 0
mirror of https://github.com/wolfpld/tracy synced 2026-01-19 04:52:09 +00:00
Code Issues Projects Releases Wiki Activity

Replace all messages text addr by TaggedUserlandAddress and send metadata over the network

Browse Source 
There are two changes to the protocol:

- `QueueMessageLiteral*` were changed and what used to be addresses are now addresses+metadata
- Other messages now send `QueueMessage*Metadata` with added metadata.

This will later be used to store and transmit message sources, level, etc.
This commit is contained in:
Clément Grégoire
2025-10-19 16:02:01 +02:00
parent 9c57b229ea
commit f981330f66
8 changed files with 169 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
manual/tracy.tex
View File

@@ -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}

42
public/client/TracyProfiler.cpp
View File

@@ -2014,7 +2014,7 @@ void Profiler::Worker()
switch( (QueueType)idx )
{
case QueueType::MessageAppInfo:
ptr = MemRead<uint64_t>( &item.messageFat.text );
ptr = MemRead<TaggedUserlandAddress>( &item.messageFat.textAndMetadata ).GetAddress();
size = MemRead<uint16_t>( &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<uint64_t>( &item.messageColorFat.text );
ptr = MemRead<TaggedUserlandAddress>( &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<uint64_t>( &item.messageFat.text );
ptr = MemRead<TaggedUserlandAddress>( &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<uint64_t>( &item->messageFat.text );
{
TaggedUserlandAddress taggedPtr = MemRead<TaggedUserlandAddress>( &item->messageFat.textAndMetadata );
ptr = taggedPtr.GetAddress();
size = MemRead<uint16_t>( &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<uint64_t>( &item->messageColorFat.text );
{
TaggedUserlandAddress taggedPtr = MemRead<TaggedUserlandAddress>( &item->messageColorFat.textAndMetadata );
ptr = taggedPtr.GetAddress();
size = MemRead<uint16_t>( &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<uint64_t>( &item->messageFat.text );
ptr = MemRead<TaggedUserlandAddress>( &item->messageFat.textAndMetadata ).GetAddress();
size = MemRead<uint16_t>( &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<uint64_t>( &item->messageFat.text );
ptr = MemRead<TaggedUserlandAddress>( &item->messageFat.textAndMetadata ).GetAddress();
uint16_t size = MemRead<uint16_t>( &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<uint64_t>( &item->messageColorFat.text );
ptr = MemRead<TaggedUserlandAddress>( &item->messageColorFat.textAndMetadata ).GetAddress();
uint16_t size = MemRead<uint16_t>( &item->messageColorFat.size );
SendSingleString( (const char*)ptr, size );
tracy_free_fast( (void*)ptr );

54
public/client/TracyProfiler.hpp
View File

@@ -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<uint16_t>::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<uint16_t>::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<uint16_t>::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

2
public/common/TracyProtocol.hpp
View File

@@ -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;

70
public/common/TracyQueue.hpp
View File

@@ -3,6 +3,7 @@
#include <stddef.h>
#include <stdint.h>
#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

2
public/tracy/Tracy.hpp
View File

@@ -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 )

24
server/TracyWorker.cpp
View File

@@ -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<MessageData>();
@@ -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<MessageData>();
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<MessageData>();
@@ -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<MessageData>();
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 );

8
server/TracyWorker.hpp
View File

@@ -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 );