tracy/server/TracyEvent.hpp

388 lines
7.0 KiB
C++
Raw Normal View History

2017-09-14 00:00:13 +00:00
#ifndef __TRACYEVENT_HPP__
#define __TRACYEVENT_HPP__
2017-10-08 21:03:38 +00:00
#include <limits>
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"
2017-09-15 18:17:39 +00:00
#include "TracyVector.hpp"
#include "tracy_flat_hash_map.hpp"
2017-09-14 00:00:13 +00:00
namespace tracy
{
#pragma pack( 1 )
struct StringRef
{
enum Type { Ptr, Idx };
2018-03-04 16:52:51 +00:00
StringRef() : str( 0 ), __data( 0 ) {}
StringRef( Type t, uint64_t data )
: 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;
};
};
struct StringIdx
{
StringIdx() : __data( 0 ) {}
2018-03-04 16:52:51 +00:00
StringIdx( uint32_t _idx )
: __data( 0 )
{
idx = _idx;
active = 1;
}
union
{
struct
{
uint32_t idx : 31;
uint32_t active : 1;
};
uint32_t __data;
};
};
struct SourceLocation
{
StringRef name;
StringRef function;
StringRef file;
uint32_t line;
uint32_t color;
};
enum { SourceLocationSize = sizeof( SourceLocation ) };
2017-10-22 13:37:24 +00:00
struct ZoneEvent
2017-09-14 00:00:13 +00:00
{
int64_t start;
int64_t end;
int32_t srcloc;
StringIdx text;
2018-06-21 23:11:03 +00:00
uint32_t callstack;
2018-06-29 14:12:17 +00:00
StringIdx name;
// This must be last. All above is read/saved as-is.
Store children vectors in a separate data collection. This reduces per-zone memory cost by 9 bytes if there are no children and increases it by 4 bytes, if there are children. This is universally a better solution, as the following data shows: +++ /home/wolf/desktop/tracy-old/android.tracy +++ Vectors: 2794480 Size 0: 2373070 (84.92%) Size 1: 70237 (2.51%) Size 2+: 351173 (12.57%) +++ /home/wolf/desktop/tracy-old/asset-new.tracy +++ Vectors: 1799227 Size 0: 1482691 (82.41%) Size 1: 93272 (5.18%) Size 2+: 223264 (12.41%) +++ /home/wolf/desktop/tracy-old/asset-new-id.tracy +++ Vectors: 1977996 Size 0: 1640817 (82.95%) Size 1: 97198 (4.91%) Size 2+: 239981 (12.13%) +++ /home/wolf/desktop/tracy-old/asset-old.tracy +++ Vectors: 1782395 Size 0: 1471437 (82.55%) Size 1: 88813 (4.98%) Size 2+: 222145 (12.46%) +++ /home/wolf/desktop/tracy-old/big.tracy +++ Vectors: 180794047 Size 0: 172696094 (95.52%) Size 1: 2799772 (1.55%) Size 2+: 5298181 (2.93%) +++ /home/wolf/desktop/tracy-old/darkrl.tracy +++ Vectors: 12014129 Size 0: 11611324 (96.65%) Size 1: 134980 (1.12%) Size 2+: 267825 (2.23%) +++ /home/wolf/desktop/tracy-old/mem.tracy +++ Vectors: 383097 Size 0: 321932 (84.03%) Size 1: 854 (0.22%) Size 2+: 60311 (15.74%) +++ /home/wolf/desktop/tracy-old/new.tracy +++ Vectors: 77536 Size 0: 63035 (81.30%) Size 1: 8886 (11.46%) Size 2+: 5615 (7.24%) +++ /home/wolf/desktop/tracy-old/selfprofile.tracy +++ Vectors: 22940871 Size 0: 22704868 (98.97%) Size 1: 73000 (0.32%) Size 2+: 163003 (0.71%) +++ /home/wolf/desktop/tracy-old/tbrowser.tracy +++ Vectors: 962682 Size 0: 695380 (72.23%) Size 1: 43007 (4.47%) Size 2+: 224295 (23.30%) +++ /home/wolf/desktop/tracy-old/virtualfile_hc.tracy +++ Vectors: 529170 Size 0: 449386 (84.92%) Size 1: 15694 (2.97%) Size 2+: 64090 (12.11%) +++ /home/wolf/desktop/tracy-old/zfile_hc.tracy +++ Vectors: 264849 Size 0: 220589 (83.29%) Size 1: 9386 (3.54%) Size 2+: 34874 (13.17%)
2018-07-22 14:05:50 +00:00
int32_t child;
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
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
};
int64_t time;
int32_t 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
{
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
{
int64_t cpuStart;
int64_t cpuEnd;
int64_t gpuStart;
int64_t gpuEnd;
int32_t srcloc;
uint32_t callstack;
// All above is read/saved as-is.
2017-11-11 20:09:48 +00:00
uint16_t thread;
int32_t child;
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
{
uint64_t ptr;
uint64_t size;
int64_t timeAlloc;
int64_t timeFree;
uint32_t csAlloc;
uint32_t csFree;
2018-04-29 01:14:18 +00:00
// All above is read/saved as-is.
uint16_t threadAlloc;
2018-04-01 00:03:34 +00:00
uint16_t threadFree;
};
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
struct CallstackFrame
{
StringIdx name;
StringIdx file;
2018-06-19 22:25:26 +00:00
uint32_t line;
};
enum { CallstackFrameSize = sizeof( CallstackFrame ) };
struct CallstackFrameData
{
CallstackFrame* data;
uint8_t size;
};
enum { CallstackFrameDataSize = sizeof( CallstackFrameData ) };
// 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 : 63;
uint64_t sel : 1;
};
uint64_t data;
};
enum { CallstackFrameIdSize = sizeof( CallstackFrameId ) };
struct CallstackFrameTree
{
CallstackFrameId frame;
uint64_t alloc;
uint32_t count;
flat_hash_map<uint64_t, CallstackFrameTree, nohash<uint64_t>> children;
flat_hash_set<uint32_t, nohash<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
{
int64_t start;
int64_t end;
uint8_t cpu;
int8_t reason;
int8_t state;
2019-08-12 22:13:50 +00:00
};
enum { ContextSwitchDataSize = sizeof( ContextSwitchData ) };
2017-10-04 16:12:11 +00:00
#pragma pack()
2017-11-11 18:21:07 +00:00
struct MessageData
{
int64_t time;
StringRef ref;
2018-05-25 19:10:22 +00:00
uint64_t thread;
2019-05-10 18:21:35 +00:00
uint32_t color;
2017-11-11 18:21:07 +00:00
};
struct ThreadData
{
uint64_t id;
2017-11-18 00:14:16 +00:00
uint64_t count;
2017-11-11 18:21:07 +00:00
Vector<ZoneEvent*> timeline;
Vector<ZoneEvent*> stack;
2017-11-11 18:21:07 +00:00
Vector<MessageData*> messages;
2019-01-14 21:56:10 +00:00
uint32_t nextZoneId;
Vector<uint32_t> zoneIdStack;
2017-11-11 18:21:07 +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;
2017-11-11 20:09:48 +00:00
Vector<GpuEvent*> timeline;
Vector<GpuEvent*> stack;
2017-11-17 23:32:15 +00:00
uint8_t accuracyBits;
float period;
GpuEvent* query[64*1024];
2017-11-11 18:44:09 +00:00
};
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();
};
2017-11-11 18:21:07 +00:00
uint32_t srcloc;
Vector<LockEventPtr> timeline;
flat_hash_map<uint64_t, uint8_t, nohash<uint64_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;
};
struct PlotItem
{
int64_t time;
double val;
};
2019-02-21 21:53:26 +00:00
enum class PlotType : uint8_t
{
User,
2019-02-21 21:45:39 +00:00
Memory,
SysTime
};
2017-11-11 18:21:07 +00:00
struct PlotData
{
uint64_t name;
double min;
double max;
2017-12-05 20:24:09 +00:00
Vector<PlotItem> data;
Vector<PlotItem> postpone;
2017-11-11 18:21:07 +00:00
uint64_t postponeTime;
PlotType type;
2017-11-11 18:21:07 +00:00
};
2018-04-01 00:03:34 +00:00
struct MemData
{
Vector<MemEvent> data;
2018-05-02 15:59:50 +00:00
Vector<uint64_t> frees;
flat_hash_map<uint64_t, size_t, nohash<uint64_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;
2018-04-01 00:03:34 +00:00
};
2018-08-05 00:09:59 +00:00
struct FrameEvent
{
int64_t start;
int64_t end;
2019-06-06 19:44:48 +00:00
int32_t frameImage;
2018-08-05 00:09:59 +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;
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( SourceLocation ) );
}
typedef tracy::power_of_two_hash_policy hash_policy;
2017-11-11 18:21:07 +00:00
};
struct SourceLocationComparator
{
bool operator()( const SourceLocation* lhs, const SourceLocation* rhs ) const
{
return memcmp( lhs, rhs, sizeof( SourceLocation ) ) == 0;
}
};
2019-06-06 19:39:54 +00:00
struct FrameImage
{
const char* ptr;
2019-06-08 10:17:18 +00:00
uint32_t csz;
2019-06-06 19:39:54 +00:00
uint16_t w, h;
2019-06-11 22:55:02 +00:00
uint32_t frameRef;
2019-06-12 13:28:32 +00:00
uint8_t flip;
2019-06-06 19:39:54 +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
};
2017-09-14 00:00:13 +00:00
}
#endif