tracy/server/TracyEvent.hpp

785 lines
23 KiB
C++
Raw Normal View History

2017-09-14 00:00:13 +00:00
#ifndef __TRACYEVENT_HPP__
#define __TRACYEVENT_HPP__
#include <assert.h>
2017-10-08 21:03:38 +00:00
#include <limits>
#include <stdint.h>
2019-10-13 13:28:52 +00:00
#include <string>
2017-11-15 20:26:58 +00:00
#include <string.h>
2017-10-08 21:03:38 +00:00
2018-02-08 16:08:31 +00:00
#include "TracyCharUtil.hpp"
#include "TracyShortPtr.hpp"
2021-02-07 14:52:08 +00:00
#include "TracySortedVector.hpp"
2017-09-15 18:17:39 +00:00
#include "TracyVector.hpp"
#include "tracy_robin_hood.h"
2019-10-29 00:32:09 +00:00
#include "../common/TracyForceInline.hpp"
2020-05-27 16:16:53 +00:00
#include "../common/TracyQueue.hpp"
2017-09-14 00:00:13 +00:00
namespace tracy
{
#pragma pack( 1 )
struct StringRef
{
enum Type { Ptr, Idx };
2019-10-29 00:32:09 +00:00
tracy_force_inline StringRef() : str( 0 ), __data( 0 ) {}
tracy_force_inline StringRef( Type t, uint64_t data )
2018-03-04 16:52:51 +00:00
: str( data )
, __data( 0 )
{
isidx = t == Idx;
active = 1;
}
2018-03-04 16:52:51 +00:00
uint64_t str;
2017-11-11 16:56:41 +00:00
union
{
struct
{
uint8_t isidx : 1;
uint8_t active : 1;
};
uint8_t __data;
};
};
2020-05-23 11:49:42 +00:00
struct StringRefHasher
{
size_t operator()( const StringRef& key ) const
{
return charutil::hash( (const char*)&key, sizeof( StringRef ) );
}
};
struct StringRefComparator
{
bool operator()( const StringRef& lhs, const StringRef& rhs ) const
{
return memcmp( &lhs, &rhs, sizeof( StringRef ) ) == 0;
}
};
class StringIdx
{
public:
2019-10-29 00:32:09 +00:00
tracy_force_inline StringIdx() { memset( m_idx, 0, sizeof( m_idx ) ); }
tracy_force_inline StringIdx( uint32_t idx )
{
SetIdx( idx );
}
2019-10-29 00:32:09 +00:00
tracy_force_inline void SetIdx( uint32_t idx )
{
idx++;
memcpy( m_idx, &idx, 3 );
}
2019-10-29 00:32:09 +00:00
tracy_force_inline uint32_t Idx() const
{
uint32_t idx = 0;
memcpy( &idx, m_idx, 3 );
assert( idx != 0 );
return idx - 1;
}
2019-10-29 00:32:09 +00:00
tracy_force_inline bool Active() const
{
uint32_t zero = 0;
return memcmp( m_idx, &zero, 3 ) != 0;
}
private:
uint8_t m_idx[3];
};
2019-10-01 19:48:34 +00:00
class Int24
{
public:
2019-10-29 00:32:09 +00:00
tracy_force_inline Int24() { memset( m_val, 0, sizeof( m_val ) ); }
tracy_force_inline Int24( uint32_t val )
2019-10-01 19:48:34 +00:00
{
SetVal( val );
}
2019-10-29 00:32:09 +00:00
tracy_force_inline void SetVal( uint32_t val )
2019-10-01 19:48:34 +00:00
{
2020-02-12 00:58:36 +00:00
memcpy( m_val, &val, 2 );
val >>= 16;
memcpy( m_val+2, &val, 1 );
2019-10-01 19:48:34 +00:00
}
2019-10-29 00:32:09 +00:00
tracy_force_inline uint32_t Val() const
2019-10-01 19:48:34 +00:00
{
2020-02-12 00:58:36 +00:00
uint8_t hi;
memcpy( &hi, m_val+2, 1 );
uint16_t lo;
memcpy( &lo, m_val, 2 );
return ( uint32_t( hi ) << 16 ) | lo;
2019-10-01 19:48:34 +00:00
}
private:
uint8_t m_val[3];
};
class Int48
{
public:
2019-11-03 13:33:13 +00:00
tracy_force_inline Int48() {}
tracy_force_inline Int48( int64_t val )
{
SetVal( val );
}
2021-06-15 00:04:32 +00:00
tracy_force_inline void Clear()
{
memset( m_val, 0, 6 );
}
tracy_force_inline void SetVal( int64_t val )
{
2020-02-12 00:58:36 +00:00
memcpy( m_val, &val, 4 );
val >>= 32;
memcpy( m_val+4, &val, 2 );
}
tracy_force_inline int64_t Val() const
{
2020-02-10 00:38:45 +00:00
int16_t hi;
memcpy( &hi, m_val+4, 2 );
uint32_t lo;
memcpy( &lo, m_val, 4 );
2020-04-14 00:16:32 +00:00
return ( int64_t( uint64_t( hi ) << 32 ) ) | lo;
}
tracy_force_inline bool IsNonNegative() const
{
return ( m_val[5] >> 7 ) == 0;
}
private:
uint8_t m_val[6];
};
2021-06-04 11:38:45 +00:00
struct Int48Sort { bool operator()( const Int48& lhs, const Int48& rhs ) { return lhs.Val() < rhs.Val(); }; };
2019-10-01 19:48:34 +00:00
struct SourceLocationBase
{
StringRef name;
StringRef function;
StringRef file;
uint32_t line;
uint32_t color;
};
struct SourceLocation : public SourceLocationBase
{
mutable uint32_t namehash;
};
enum { SourceLocationSize = sizeof( SourceLocation ) };
2017-10-22 13:37:24 +00:00
struct ZoneEvent
2017-09-14 00:00:13 +00:00
{
2019-10-29 00:32:09 +00:00
tracy_force_inline ZoneEvent() {};
tracy_force_inline int64_t Start() const { return int64_t( _start_srcloc ) >> 16; }
tracy_force_inline void SetStart( int64_t start ) { assert( start < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_start_srcloc)+2, &start, 4 ); memcpy( ((char*)&_start_srcloc)+6, ((char*)&start)+4, 2 ); }
tracy_force_inline int64_t End() const { return int64_t( _end_child1 ) >> 16; }
tracy_force_inline void SetEnd( int64_t end ) { assert( end < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_end_child1)+2, &end, 4 ); memcpy( ((char*)&_end_child1)+6, ((char*)&end)+4, 2 ); }
tracy_force_inline bool IsEndValid() const { return ( _end_child1 >> 63 ) == 0; }
2019-10-29 00:32:09 +00:00
tracy_force_inline int16_t SrcLoc() const { return int16_t( _start_srcloc & 0xFFFF ); }
tracy_force_inline void SetSrcLoc( int16_t srcloc ) { memcpy( &_start_srcloc, &srcloc, 2 ); }
tracy_force_inline int32_t Child() const { int32_t child; memcpy( &child, &_child2, 4 ); return child; }
tracy_force_inline void SetChild( int32_t child ) { memcpy( &_child2, &child, 4 ); }
tracy_force_inline bool HasChildren() const { uint8_t tmp; memcpy( &tmp, ((char*)&_end_child1)+1, 1 ); return ( tmp >> 7 ) == 0; }
tracy_force_inline void SetStartSrcLoc( int64_t start, int16_t srcloc ) { assert( start < (int64_t)( 1ull << 47 ) ); start <<= 16; start |= uint16_t( srcloc ); memcpy( &_start_srcloc, &start, 8 ); }
uint64_t _start_srcloc;
uint16_t _child2;
uint64_t _end_child1;
uint32_t extra;
2017-09-14 00:00:13 +00:00
};
2017-10-22 13:37:24 +00:00
enum { ZoneEventSize = sizeof( ZoneEvent ) };
static_assert( std::is_standard_layout<ZoneEvent>::value, "ZoneEvent is not standard layout" );
2017-10-04 14:16:40 +00:00
2019-08-15 12:15:40 +00:00
struct ZoneExtra
{
Int24 callstack;
StringIdx text;
StringIdx name;
Int24 color;
};
enum { ZoneExtraSize = sizeof( ZoneExtra ) };
// This union exploits the fact that the current implementations of x64 and arm64 do not provide
// full 64 bit address space. The high bits must be bit-extended, so 0x80... is an invalid pointer.
// This allows using the highest bit as a selector between a native pointer and a table index here.
union CallstackFrameId
{
struct
{
uint64_t idx : 62;
uint64_t sel : 1;
uint64_t custom : 1;
};
uint64_t data;
};
enum { CallstackFrameIdSize = sizeof( CallstackFrameId ) };
static tracy_force_inline bool operator==( const CallstackFrameId& lhs, const CallstackFrameId& rhs ) { return lhs.data == rhs.data; }
2020-02-22 15:39:39 +00:00
struct SampleData
{
Int48 time;
Int24 callstack;
};
enum { SampleDataSize = sizeof( SampleData ) };
struct SampleDataRange
{
Int48 time;
CallstackFrameId ip;
};
enum { SampleDataRangeSize = sizeof( SampleDataRange ) };
2021-05-19 21:05:33 +00:00
struct HwSampleData
{
2021-06-04 11:38:45 +00:00
SortedVector<Int48, Int48Sort> cycles;
SortedVector<Int48, Int48Sort> retired;
SortedVector<Int48, Int48Sort> cacheRef;
SortedVector<Int48, Int48Sort> cacheMiss;
SortedVector<Int48, Int48Sort> branchRetired;
SortedVector<Int48, Int48Sort> branchMiss;
bool is_sorted() const
{
return
cycles.is_sorted() &&
retired.is_sorted() &&
cacheRef.is_sorted() &&
cacheMiss.is_sorted() &&
branchRetired.is_sorted() &&
branchMiss.is_sorted();
}
void sort()
{
if( !cycles.is_sorted() ) cycles.sort();
if( !retired.is_sorted() ) retired.sort();
if( !cacheRef.is_sorted() ) cacheRef.sort();
if( !cacheMiss.is_sorted() ) cacheMiss.sort();
if( !branchRetired.is_sorted() ) branchRetired.sort();
if( !branchMiss.is_sorted() ) branchMiss.sort();
}
2021-05-19 21:05:33 +00:00
};
enum { HwSampleDataSize = sizeof( HwSampleData ) };
2017-10-04 14:16:40 +00:00
struct LockEvent
{
2017-10-04 16:17:31 +00:00
enum class Type : uint8_t
{
Wait,
Obtain,
2017-12-10 21:42:39 +00:00
Release,
WaitShared,
ObtainShared,
ReleaseShared
2017-10-04 16:17:31 +00:00
};
2019-10-29 00:32:09 +00:00
tracy_force_inline int64_t Time() const { return int64_t( _time_srcloc ) >> 16; }
tracy_force_inline void SetTime( int64_t time ) { assert( time < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_time_srcloc)+2, &time, 4 ); memcpy( ((char*)&_time_srcloc)+6, ((char*)&time)+4, 2 ); }
tracy_force_inline int16_t SrcLoc() const { return int16_t( _time_srcloc & 0xFFFF ); }
tracy_force_inline void SetSrcLoc( int16_t srcloc ) { memcpy( &_time_srcloc, &srcloc, 2 ); }
2019-08-15 19:34:19 +00:00
uint64_t _time_srcloc;
2017-12-05 21:34:48 +00:00
uint8_t thread;
2017-12-10 21:37:56 +00:00
Type type;
};
struct LockEventShared : public LockEvent
{
uint64_t waitShared;
2017-12-10 21:42:39 +00:00
uint64_t sharedList;
2017-10-04 14:16:40 +00:00
};
struct LockEventPtr
{
2019-11-02 14:40:06 +00:00
short_ptr<LockEvent> ptr;
uint8_t lockingThread;
uint8_t lockCount;
uint64_t waitList;
};
2017-10-04 14:16:40 +00:00
enum { LockEventSize = sizeof( LockEvent ) };
enum { LockEventSharedSize = sizeof( LockEventShared ) };
enum { LockEventPtrSize = sizeof( LockEventPtr ) };
2017-10-04 14:16:40 +00:00
enum { MaxLockThreads = sizeof( LockEventPtr::waitList ) * 8 };
static_assert( std::numeric_limits<decltype(LockEventPtr::lockCount)>::max() >= MaxLockThreads, "Not enough space for lock count." );
2017-10-08 21:03:38 +00:00
2017-11-11 20:09:48 +00:00
struct GpuEvent
{
2019-10-29 00:32:09 +00:00
tracy_force_inline int64_t CpuStart() const { return int64_t( _cpuStart_srcloc ) >> 16; }
tracy_force_inline void SetCpuStart( int64_t cpuStart ) { assert( cpuStart < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_cpuStart_srcloc)+2, &cpuStart, 4 ); memcpy( ((char*)&_cpuStart_srcloc)+6, ((char*)&cpuStart)+4, 2 ); }
tracy_force_inline int64_t CpuEnd() const { return int64_t( _cpuEnd_thread ) >> 16; }
tracy_force_inline void SetCpuEnd( int64_t cpuEnd ) { assert( cpuEnd < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_cpuEnd_thread)+2, &cpuEnd, 4 ); memcpy( ((char*)&_cpuEnd_thread)+6, ((char*)&cpuEnd)+4, 2 ); }
tracy_force_inline int64_t GpuStart() const { return int64_t( _gpuStart_child1 ) >> 16; }
tracy_force_inline void SetGpuStart( int64_t gpuStart ) { /*assert( gpuStart < (int64_t)( 1ull << 47 ) );*/ memcpy( ((char*)&_gpuStart_child1)+2, &gpuStart, 4 ); memcpy( ((char*)&_gpuStart_child1)+6, ((char*)&gpuStart)+4, 2 ); }
tracy_force_inline int64_t GpuEnd() const { return int64_t( _gpuEnd_child2 ) >> 16; }
tracy_force_inline void SetGpuEnd( int64_t gpuEnd ) { assert( gpuEnd < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_gpuEnd_child2)+2, &gpuEnd, 4 ); memcpy( ((char*)&_gpuEnd_child2)+6, ((char*)&gpuEnd)+4, 2 ); }
2019-10-29 00:32:09 +00:00
tracy_force_inline int16_t SrcLoc() const { return int16_t( _cpuStart_srcloc & 0xFFFF ); }
tracy_force_inline void SetSrcLoc( int16_t srcloc ) { memcpy( &_cpuStart_srcloc, &srcloc, 2 ); }
tracy_force_inline uint16_t Thread() const { return uint16_t( _cpuEnd_thread & 0xFFFF ); }
tracy_force_inline void SetThread( uint16_t thread ) { memcpy( &_cpuEnd_thread, &thread, 2 ); }
tracy_force_inline int32_t Child() const { return int32_t( uint32_t( _gpuStart_child1 & 0xFFFF ) | ( uint32_t( _gpuEnd_child2 & 0xFFFF ) << 16 ) ); }
tracy_force_inline void SetChild( int32_t child ) { memcpy( &_gpuStart_child1, &child, 2 ); memcpy( &_gpuEnd_child2, ((char*)&child)+2, 2 ); }
uint64_t _cpuStart_srcloc;
uint64_t _cpuEnd_thread;
uint64_t _gpuStart_child1;
uint64_t _gpuEnd_child2;
Int24 callstack;
2017-11-11 20:09:48 +00:00
};
enum { GpuEventSize = sizeof( GpuEvent ) };
static_assert( std::is_standard_layout<GpuEvent>::value, "GpuEvent is not standard layout" );
2017-11-11 20:09:48 +00:00
2018-04-01 00:03:34 +00:00
struct MemEvent
{
tracy_force_inline uint64_t Ptr() const { return uint64_t( int64_t( _ptr_csalloc1 ) >> 8 ); }
tracy_force_inline void SetPtr( uint64_t ptr ) { memcpy( ((char*)&_ptr_csalloc1)+1, &ptr, 4 ); memcpy( ((char*)&_ptr_csalloc1)+5, ((char*)&ptr)+4, 2 ); memcpy( ((char*)&_ptr_csalloc1)+7, ((char*)&ptr)+6, 1 ); }
tracy_force_inline uint64_t Size() const { return _size_csalloc2 >> 16; }
tracy_force_inline void SetSize( uint64_t size ) { assert( size < ( 1ull << 47 ) ); memcpy( ((char*)&_size_csalloc2)+2, &size, 4 ); memcpy( ((char*)&_size_csalloc2)+6, ((char*)&size)+4, 2 ); }
tracy_force_inline uint32_t CsAlloc() const { return uint8_t( _ptr_csalloc1 ) | ( uint16_t( _size_csalloc2 ) << 8 ); }
tracy_force_inline void SetCsAlloc( uint32_t csAlloc ) { memcpy( &_ptr_csalloc1, &csAlloc, 1 ); memcpy( &_size_csalloc2, ((char*)&csAlloc)+1, 2 ); }
2019-10-29 00:32:09 +00:00
tracy_force_inline int64_t TimeAlloc() const { return int64_t( _time_thread_alloc ) >> 16; }
tracy_force_inline void SetTimeAlloc( int64_t time ) { assert( time < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_time_thread_alloc)+2, &time, 4 ); memcpy( ((char*)&_time_thread_alloc)+6, ((char*)&time)+4, 2 ); }
tracy_force_inline int64_t TimeFree() const { return int64_t( _time_thread_free ) >> 16; }
tracy_force_inline void SetTimeFree( int64_t time ) { assert( time < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_time_thread_free)+2, &time, 4 ); memcpy( ((char*)&_time_thread_free)+6, ((char*)&time)+4, 2 ); }
tracy_force_inline uint16_t ThreadAlloc() const { return uint16_t( _time_thread_alloc ); }
tracy_force_inline void SetThreadAlloc( uint16_t thread ) { memcpy( &_time_thread_alloc, &thread, 2 ); }
tracy_force_inline uint16_t ThreadFree() const { return uint16_t( _time_thread_free ); }
tracy_force_inline void SetThreadFree( uint16_t thread ) { memcpy( &_time_thread_free, &thread, 2 ); }
tracy_force_inline void SetTimeThreadAlloc( int64_t time, uint16_t thread ) { time <<= 16; time |= thread; memcpy( &_time_thread_alloc, &time, 8 ); }
2020-04-13 23:59:17 +00:00
tracy_force_inline void SetTimeThreadFree( int64_t time, uint16_t thread ) { uint64_t t; memcpy( &t, &time, 8 ); t <<= 16; t |= thread; memcpy( &_time_thread_free, &t, 8 ); }
uint64_t _ptr_csalloc1;
uint64_t _size_csalloc2;
Int24 csFree;
uint64_t _time_thread_alloc;
uint64_t _time_thread_free;
2018-04-01 00:03:34 +00:00
};
enum { MemEventSize = sizeof( MemEvent ) };
static_assert( std::is_standard_layout<MemEvent>::value, "MemEvent is not standard layout" );
2018-06-19 22:25:26 +00:00
2020-02-25 22:42:59 +00:00
struct CallstackFrameBasic
2018-06-19 22:25:26 +00:00
{
StringIdx name;
StringIdx file;
2018-06-19 22:25:26 +00:00
uint32_t line;
};
2020-02-25 22:42:59 +00:00
struct CallstackFrame : public CallstackFrameBasic
{
uint64_t symAddr;
};
2020-02-26 21:35:15 +00:00
struct SymbolData : public CallstackFrameBasic
{
StringIdx imageName;
2020-02-27 13:35:00 +00:00
StringIdx callFile;
uint32_t callLine;
2020-02-27 14:28:58 +00:00
uint8_t isInline;
2020-03-25 17:32:36 +00:00
Int24 size;
2020-02-26 21:35:15 +00:00
};
enum { CallstackFrameBasicSize = sizeof( CallstackFrameBasic ) };
2018-06-19 22:25:26 +00:00
enum { CallstackFrameSize = sizeof( CallstackFrame ) };
2020-02-26 21:35:15 +00:00
enum { SymbolDataSize = sizeof( SymbolData ) };
2018-06-19 22:25:26 +00:00
2020-03-27 16:34:51 +00:00
struct SymbolLocation
{
uint64_t addr;
uint32_t len;
};
enum { SymbolLocationSize = sizeof( SymbolLocation ) };
struct CallstackFrameData
{
short_ptr<CallstackFrame> data;
uint8_t size;
2020-02-25 23:55:43 +00:00
StringIdx imageName;
};
enum { CallstackFrameDataSize = sizeof( CallstackFrameData ) };
struct CallstackFrameTree
{
CallstackFrameTree( CallstackFrameId id ) : frame( id ), alloc( 0 ), count( 0 ) {}
CallstackFrameId frame;
uint64_t alloc;
uint32_t count;
unordered_flat_map<uint64_t, CallstackFrameTree> children;
unordered_flat_set<uint32_t> callstacks;
};
enum { CallstackFrameTreeSize = sizeof( CallstackFrameTree ) };
2018-08-20 00:07:31 +00:00
struct CrashEvent
{
uint64_t thread = 0;
int64_t time = 0;
uint64_t message = 0;
uint32_t callstack = 0;
};
enum { CrashEventSize = sizeof( CrashEvent ) };
2019-08-12 22:13:50 +00:00
struct ContextSwitchData
{
2019-08-17 14:26:59 +00:00
enum : int8_t { NoState = 100 };
2019-08-17 15:05:29 +00:00
enum : int8_t { Wakeup = -2 };
2019-08-17 14:26:59 +00:00
2019-10-29 00:32:09 +00:00
tracy_force_inline int64_t Start() const { return int64_t( _start_cpu ) >> 16; }
tracy_force_inline void SetStart( int64_t start ) { assert( start < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_start_cpu)+2, &start, 4 ); memcpy( ((char*)&_start_cpu)+6, ((char*)&start)+4, 2 ); }
tracy_force_inline int64_t End() const { return int64_t( _end_reason_state ) >> 16; }
tracy_force_inline void SetEnd( int64_t end ) { assert( end < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_end_reason_state)+2, &end, 4 ); memcpy( ((char*)&_end_reason_state)+6, ((char*)&end)+4, 2 ); }
tracy_force_inline bool IsEndValid() const { return ( _end_reason_state >> 63 ) == 0; }
2019-10-29 00:32:09 +00:00
tracy_force_inline uint8_t Cpu() const { return uint8_t( _start_cpu & 0xFF ); }
tracy_force_inline void SetCpu( uint8_t cpu ) { memcpy( &_start_cpu, &cpu, 1 ); }
tracy_force_inline int8_t Reason() const { return int8_t( (_end_reason_state >> 8) & 0xFF ); }
tracy_force_inline void SetReason( int8_t reason ) { memcpy( ((char*)&_end_reason_state)+1, &reason, 1 ); }
tracy_force_inline int8_t State() const { return int8_t( _end_reason_state & 0xFF ); }
tracy_force_inline void SetState( int8_t state ) { memcpy( &_end_reason_state, &state, 1 ); }
tracy_force_inline int64_t WakeupVal() const { return _wakeup.Val(); }
tracy_force_inline void SetWakeup( int64_t wakeup ) { assert( wakeup < (int64_t)( 1ull << 47 ) ); _wakeup.SetVal( wakeup ); }
2020-02-20 01:05:23 +00:00
tracy_force_inline void SetStartCpu( int64_t start, uint8_t cpu ) { assert( start < (int64_t)( 1ull << 47 ) ); _start_cpu = ( uint64_t( start ) << 16 ) | cpu; }
tracy_force_inline void SetEndReasonState( int64_t end, int8_t reason, int8_t state ) { assert( end < (int64_t)( 1ull << 47 ) ); _end_reason_state = ( uint64_t( end ) << 16 ) | ( uint64_t( reason ) << 8 ) | uint8_t( state ); }
uint64_t _start_cpu;
uint64_t _end_reason_state;
Int48 _wakeup;
2019-08-12 22:13:50 +00:00
};
enum { ContextSwitchDataSize = sizeof( ContextSwitchData ) };
2017-11-11 18:21:07 +00:00
2019-08-16 14:28:58 +00:00
struct ContextSwitchCpu
{
2019-10-29 00:32:09 +00:00
tracy_force_inline int64_t Start() const { return int64_t( _start_thread ) >> 16; }
tracy_force_inline void SetStart( int64_t start ) { assert( start < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_start_thread)+2, &start, 4 ); memcpy( ((char*)&_start_thread)+6, ((char*)&start)+4, 2 ); }
tracy_force_inline int64_t End() const { int64_t v; memcpy( &v, ((char*)&_end)-2, 8 ); return v >> 16; }
tracy_force_inline void SetEnd( int64_t end ) { assert( end < (int64_t)( 1ull << 47 ) ); _end.SetVal( end ); }
tracy_force_inline bool IsEndValid() const { return _end.IsNonNegative(); }
2019-10-29 00:32:09 +00:00
tracy_force_inline uint16_t Thread() const { return uint16_t( _start_thread ); }
tracy_force_inline void SetThread( uint16_t thread ) { memcpy( &_start_thread, &thread, 2 ); }
2020-02-20 01:09:09 +00:00
tracy_force_inline void SetStartThread( int64_t start, uint16_t thread ) { assert( start < (int64_t)( 1ull << 47 ) ); _start_thread = ( uint64_t( start ) << 16 ) | thread; }
uint64_t _start_thread;
Int48 _end;
2019-08-16 14:28:58 +00:00
};
enum { ContextSwitchCpuSize = sizeof( ContextSwitchCpu ) };
2019-11-04 23:30:57 +00:00
struct ContextSwitchUsage
{
ContextSwitchUsage() {}
ContextSwitchUsage( int64_t time, uint8_t other, uint8_t own ) { SetTime( time ); SetOther( other ); SetOwn( own ); }
tracy_force_inline int64_t Time() const { return int64_t( _time_other_own ) >> 16; }
tracy_force_inline void SetTime( int64_t time ) { assert( time < (int64_t)( 1ull << 47 ) ); memcpy( ((char*)&_time_other_own)+2, &time, 4 ); memcpy( ((char*)&_time_other_own)+6, ((char*)&time)+4, 2 ); }
tracy_force_inline uint8_t Other() const { return uint8_t( _time_other_own ); }
tracy_force_inline void SetOther( uint8_t other ) { memcpy( &_time_other_own, &other, 1 ); }
tracy_force_inline uint8_t Own() const { uint8_t v; memcpy( &v, ((char*)&_time_other_own)+1, 1 );return v; }
2019-11-04 23:30:57 +00:00
tracy_force_inline void SetOwn( uint8_t own ) { memcpy( ((char*)&_time_other_own)+1, &own, 1 ); }
uint64_t _time_other_own;
};
enum { ContextSwitchUsageSize = sizeof( ContextSwitchUsage ) };
2017-11-11 18:21:07 +00:00
struct MessageData
{
int64_t time;
StringRef ref;
2019-08-28 19:03:01 +00:00
uint16_t thread;
2019-05-10 18:21:35 +00:00
uint32_t color;
2019-11-14 23:42:44 +00:00
Int24 callstack;
2017-11-11 18:21:07 +00:00
};
2019-08-15 12:15:40 +00:00
enum { MessageDataSize = sizeof( MessageData ) };
struct PlotItem
{
Int48 time;
double val;
};
enum { PlotItemSize = sizeof( PlotItem ) };
struct FrameEvent
{
int64_t start;
int64_t end;
int32_t frameImage;
};
enum { FrameEventSize = sizeof( FrameEvent ) };
2020-03-10 18:39:22 +00:00
struct FrameImage
{
short_ptr<const char> ptr;
uint32_t csz;
uint16_t w, h;
uint32_t frameRef;
uint8_t flip;
};
enum { FrameImageSize = sizeof( FrameImage ) };
2020-03-10 20:06:38 +00:00
struct GhostZone
{
Int48 start, end;
2020-03-10 21:04:12 +00:00
Int24 frame;
2020-03-10 20:06:38 +00:00
int32_t child;
};
enum { GhostZoneSize = sizeof( GhostZone ) };
2019-08-15 19:42:24 +00:00
#pragma pack()
2017-11-11 18:21:07 +00:00
struct ThreadData
{
uint64_t id;
2017-11-18 00:14:16 +00:00
uint64_t count;
2019-11-02 15:17:20 +00:00
Vector<short_ptr<ZoneEvent>> timeline;
Vector<short_ptr<ZoneEvent>> stack;
Vector<short_ptr<MessageData>> messages;
2019-01-14 21:56:10 +00:00
uint32_t nextZoneId;
Vector<uint32_t> zoneIdStack;
#ifndef TRACY_NO_STATISTICS
Vector<int64_t> childTimeStack;
2020-03-10 20:06:38 +00:00
Vector<GhostZone> ghostZones;
uint64_t ghostIdx;
#endif
2020-02-22 15:39:39 +00:00
Vector<SampleData> samples;
SampleData pendingSample;
2021-06-16 23:47:19 +00:00
uint64_t kernelSampleCnt;
2017-11-11 18:21:07 +00:00
};
2019-09-23 15:27:49 +00:00
struct GpuCtxThreadData
{
2019-11-02 14:52:34 +00:00
Vector<short_ptr<GpuEvent>> timeline;
Vector<short_ptr<GpuEvent>> stack;
2019-09-23 15:27:49 +00:00
};
2017-11-11 18:44:09 +00:00
struct GpuCtxData
{
int64_t timeDiff;
2017-11-13 23:48:26 +00:00
uint64_t thread;
2017-11-18 00:07:28 +00:00
uint64_t count;
float period;
GpuContextType type;
bool hasPeriod;
2020-07-07 19:09:37 +00:00
bool hasCalibration;
int64_t calibratedGpuTime;
int64_t calibratedCpuTime;
double calibrationMod;
int64_t lastGpuTime;
uint64_t overflow;
uint32_t overflowMul;
2021-01-31 17:56:03 +00:00
StringIdx name;
unordered_flat_map<uint64_t, GpuCtxThreadData> threadData;
short_ptr<GpuEvent> query[64*1024];
2017-11-11 18:44:09 +00:00
};
enum { GpuCtxDataSize = sizeof( GpuCtxData ) };
2020-03-02 00:58:48 +00:00
enum class LockType : uint8_t;
2017-11-11 18:21:07 +00:00
struct LockMap
{
struct TimeRange
{
int64_t start = std::numeric_limits<int64_t>::max();
int64_t end = std::numeric_limits<int64_t>::min();
};
2020-03-08 12:47:38 +00:00
StringIdx customName;
int16_t srcloc;
Vector<LockEventPtr> timeline;
unordered_flat_map<uint64_t, uint8_t> threadMap;
2017-11-11 18:21:07 +00:00
std::vector<uint64_t> threadList;
2017-12-10 20:37:39 +00:00
LockType type;
int64_t timeAnnounce;
int64_t timeTerminate;
2017-12-10 20:37:39 +00:00
bool valid;
2019-05-12 14:17:17 +00:00
bool isContended;
TimeRange range[64];
2017-11-11 18:21:07 +00:00
};
struct LockHighlight
{
int64_t id;
int64_t begin;
int64_t end;
uint8_t thread;
bool blocked;
};
2019-02-21 21:53:26 +00:00
enum class PlotType : uint8_t
{
User,
2019-02-21 21:45:39 +00:00
Memory,
SysTime
};
enum class PlotValueFormatting : uint8_t
{
Number,
Memory,
Percentage
};
2017-11-11 18:21:07 +00:00
struct PlotData
{
2021-02-07 14:52:08 +00:00
struct PlotItemSort { bool operator()( const PlotItem& lhs, const PlotItem& rhs ) { return lhs.time.Val() < rhs.time.Val(); }; };
2017-11-11 18:21:07 +00:00
uint64_t name;
double min;
double max;
2021-02-07 14:52:08 +00:00
SortedVector<PlotItem, PlotItemSort> data;
PlotType type;
PlotValueFormatting format;
2017-11-11 18:21:07 +00:00
};
2018-04-01 00:03:34 +00:00
struct MemData
{
Vector<MemEvent> data;
Vector<uint32_t> frees;
unordered_flat_map<uint64_t, size_t> active;
2018-04-01 00:03:34 +00:00
uint64_t high = std::numeric_limits<uint64_t>::min();
uint64_t low = std::numeric_limits<uint64_t>::max();
2018-04-01 22:00:49 +00:00
uint64_t usage = 0;
PlotData* plot = nullptr;
2020-09-25 14:39:00 +00:00
bool reconstruct = false;
2020-09-25 14:36:03 +00:00
uint64_t name = 0;
2018-04-01 00:03:34 +00:00
};
2018-08-04 17:47:09 +00:00
struct FrameData
{
uint64_t name;
2018-08-05 00:09:59 +00:00
Vector<FrameEvent> frames;
uint8_t continuous;
2019-09-16 19:31:43 +00:00
int64_t min = std::numeric_limits<int64_t>::max();
int64_t max = std::numeric_limits<int64_t>::min();
int64_t total = 0;
double sumSq = 0;
2018-08-04 17:47:09 +00:00
};
2017-11-11 18:21:07 +00:00
struct StringLocation
{
const char* ptr;
uint32_t idx;
};
struct SourceLocationHasher
{
size_t operator()( const SourceLocation* ptr ) const
{
return charutil::hash( (const char*)ptr, sizeof( SourceLocationBase ) );
2017-11-11 18:21:07 +00:00
}
};
struct SourceLocationComparator
{
bool operator()( const SourceLocation* lhs, const SourceLocation* rhs ) const
{
return memcmp( lhs, rhs, sizeof( SourceLocationBase ) ) == 0;
2017-11-11 18:21:07 +00:00
}
};
2019-08-15 12:15:40 +00:00
2019-08-12 22:13:50 +00:00
struct ContextSwitch
{
Vector<ContextSwitchData> v;
int64_t runningTime = 0;
2019-08-12 22:13:50 +00:00
};
2019-08-16 14:28:58 +00:00
struct CpuData
{
Vector<ContextSwitchCpu> cs;
};
2019-08-17 23:50:49 +00:00
struct CpuThreadData
{
int64_t runningTime = 0;
uint32_t runningRegions = 0;
uint32_t migrations = 0;
};
2019-08-17 23:53:38 +00:00
enum { CpuThreadDataSize = sizeof( CpuThreadData ) };
struct Parameter
{
uint32_t idx;
StringRef name;
bool isBool;
int32_t val;
};
struct SymbolStats
{
uint32_t incl, excl;
unordered_flat_map<uint32_t, uint32_t> parents;
};
enum { SymbolStatsSize = sizeof( SymbolStats ) };
2017-09-14 00:00:13 +00:00
}
#endif