tracy/server/TracyEvent.hpp

260 lines
4.6 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;
2017-10-01 17:16:44 +00:00
int8_t cpu_start;
int8_t cpu_end;
StringIdx text;
// This must be last. All above is read/saved as-is.
2017-10-22 13:37:24 +00:00
Vector<ZoneEvent*> 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;
uint8_t lockingThread;
2017-12-10 21:37:56 +00:00
Type type;
2017-10-04 17:42:44 +00:00
uint8_t lockCount;
2017-12-09 18:13:59 +00:00
uint64_t waitList;
};
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
};
enum { LockEventSize = sizeof( LockEvent ) };
enum { LockEventSharedSize = sizeof( LockEventShared ) };
2017-10-04 14:16:40 +00:00
2017-10-08 21:03:38 +00:00
enum { MaxLockThreads = sizeof( LockEvent::waitList ) * 8 };
static_assert( std::numeric_limits<decltype(LockEvent::lockCount)>::max() >= MaxLockThreads, "Not enough space for lock count." );
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;
// This must be last. All above is read/saved as-is.
2017-11-11 20:09:48 +00:00
Vector<GpuEvent*> child;
};
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;
uint16_t threadAlloc;
int64_t timeFree;
uint16_t threadFree;
};
enum { MemEventSize = sizeof( MemEvent ) };
static_assert( std::is_standard_layout<MemEvent>::value, "MemEvent is not standard layout" );
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;
};
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;
};
struct GpuCtxResync
{
int64_t timeDiff;
uint16_t events;
};
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;
Vector<GpuEvent*> queue;
Vector<GpuCtxResync> resync;
2017-11-17 23:32:15 +00:00
uint8_t accuracyBits;
2017-11-11 18:44:09 +00:00
};
2017-11-11 18:21:07 +00:00
struct LockMap
{
uint32_t srcloc;
Vector<LockEvent*> 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;
bool valid;
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;
};
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;
};
2018-04-01 00:03:34 +00:00
struct MemData
{
Vector<MemEvent> data;
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;
2018-04-01 00:03:34 +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;
}
};
2017-09-14 00:00:13 +00:00
}
#endif