tracy/server/TracyView.hpp

868 lines
30 KiB
C++
Raw Normal View History

2017-09-12 23:33:50 +00:00
#ifndef __TRACYVIEW_HPP__
#define __TRACYVIEW_HPP__
#include <array>
2017-09-12 23:33:50 +00:00
#include <atomic>
#include <functional>
2018-08-17 12:44:41 +00:00
#include <memory>
2017-09-12 23:33:50 +00:00
#include <string>
#include <thread>
2017-09-14 00:00:13 +00:00
#include <vector>
2022-07-02 15:00:08 +00:00
#include "imgui.h"
2020-04-17 17:09:13 +00:00
#include "TracyBadVersion.hpp"
#include "TracyBuzzAnim.hpp"
2023-05-01 12:41:38 +00:00
#include "TracyConfig.hpp"
#include "TracyDecayValue.hpp"
#include "TracyFileWrite.hpp"
2019-11-02 14:52:34 +00:00
#include "TracyShortPtr.hpp"
2021-03-27 12:25:21 +00:00
#include "TracySourceContents.hpp"
#include "TracyTimelineController.hpp"
2019-07-26 21:05:24 +00:00
#include "TracyUserData.hpp"
#include "TracyUtility.hpp"
2017-09-15 18:17:39 +00:00
#include "TracyVector.hpp"
#include "TracyViewData.hpp"
#include "TracyWorker.hpp"
#include "tracy_robin_hood.h"
2017-09-12 23:33:50 +00:00
namespace tracy
{
2022-07-02 11:23:52 +00:00
constexpr const char* GpuContextNames[] = {
"Invalid",
"OpenGL",
"Vulkan",
"OpenCL",
"Direct3D 12",
"Direct3D 11"
};
struct MemoryPage;
2017-09-30 14:58:02 +00:00
class FileRead;
class SourceView;
struct TimelineContext;
struct TimelineDraw;
struct ContextSwitchDraw;
2023-03-22 21:25:55 +00:00
struct SamplesDraw;
struct MessagesDraw;
struct CpuUsageDraw;
struct CpuCtxDraw;
2023-04-15 10:51:10 +00:00
struct LockDraw;
2023-04-18 18:30:54 +00:00
struct PlotDraw;
2017-09-13 21:40:28 +00:00
2017-09-12 23:33:50 +00:00
class View
{
2017-11-27 21:41:30 +00:00
struct Animation
{
bool active = false;
int64_t start0, start1;
int64_t end0, end1;
double progress;
};
struct Region
{
bool active = false;
int64_t start;
int64_t end;
};
2019-10-20 01:24:58 +00:00
struct ZoneTimeData
{
int64_t time;
uint64_t count;
};
enum class AccumulationMode
{
SelfOnly,
AllChildren,
NonReentrantChildren
};
2020-11-01 15:24:08 +00:00
struct StatisticsCache
{
RangeSlim range;
AccumulationMode accumulationMode;
2020-11-01 15:24:08 +00:00
size_t sourceCount;
size_t count;
int64_t total;
2023-12-20 16:06:28 +00:00
uint16_t threadNum;
2020-11-01 15:24:08 +00:00
};
2017-09-12 23:33:50 +00:00
public:
2019-03-17 16:21:30 +00:00
struct PlotView
{
double min;
double max;
};
using SetTitleCallback = void(*)( const char* );
using SetScaleCallback = void(*)( float, ImFont*&, ImFont*&, ImFont*& );
2022-10-13 17:31:47 +00:00
using AttentionCallback = void(*)();
2023-05-01 12:41:38 +00:00
View( void(*cbMainThread)(const std::function<void()>&, bool), const char* addr, uint16_t port, ImFont* fixedWidth, ImFont* smallFont, ImFont* bigFont, SetTitleCallback stcb, SetScaleCallback sscb, AttentionCallback acb, const Config& config );
View( void(*cbMainThread)(const std::function<void()>&, bool), FileRead& f, ImFont* fixedWidth, ImFont* smallFont, ImFont* bigFont, SetTitleCallback stcb, SetScaleCallback sscb, AttentionCallback acb, const Config& config );
2017-09-12 23:33:50 +00:00
~View();
2022-10-13 17:50:35 +00:00
bool Draw();
bool WasActive() const;
void NotifyRootWindowSize( float w, float h ) { m_rootWidth = w; m_rootHeight = h; }
void ViewSource( const char* fileName, int line );
void ViewSource( const char* fileName, int line, const char* functionName );
void ViewSourceCheckKeyMod( const char* fileName, int line, const char* functionName );
void ViewSymbol( const char* fileName, int line, uint64_t baseAddr, uint64_t symAddr );
bool ViewDispatch( const char* fileName, int line, uint64_t symAddr );
bool ReconnectRequested() const { return m_reconnectRequested; }
std::string GetAddress() const { return m_worker.GetAddr(); }
2020-10-02 16:51:54 +00:00
uint16_t GetPort() const { return m_worker.GetPort(); }
2020-04-17 16:59:24 +00:00
const char* SourceSubstitution( const char* srcFile ) const;
void ShowSampleParents( uint64_t symAddr, bool withInlines ) { m_sampleParents.symAddr = symAddr; m_sampleParents.sel = 0; m_sampleParents.withInlines = withInlines; }
2022-09-04 12:22:43 +00:00
ViewData& GetViewData() { return m_vd; }
2020-08-09 19:11:18 +00:00
const ViewData& GetViewData() const { return m_vd; }
2022-08-15 19:21:50 +00:00
ShortenName GetShortenName() const { return m_shortenName; }
2022-09-04 11:37:19 +00:00
int GetNextGpuIdx() { return m_gpuIdx++; }
2020-08-09 19:11:18 +00:00
const MessageData* GetMessageHighlight() const { return m_msgHighlight; }
uint32_t GetLockInfoWindow() const { return m_lockInfoWindow; }
2023-04-08 16:44:17 +00:00
tracy_force_inline bool& Vis( const void* ptr )
{
auto it = m_visMap.find( ptr );
if( it == m_visMap.end() ) it = m_visMap.emplace( ptr, true ).first;
return it->second;
}
void HighlightThread( uint64_t thread );
2022-09-03 14:53:02 +00:00
void ZoomToRange( int64_t start, int64_t end, bool pause = true );
2023-04-18 18:30:54 +00:00
bool DrawPlot( const TimelineContext& ctx, PlotData& plot, const std::vector<uint32_t>& plotDraw, int& offset );
2023-04-15 10:51:10 +00:00
void DrawThread( const TimelineContext& ctx, const ThreadData& thread, const std::vector<TimelineDraw>& draw, const std::vector<ContextSwitchDraw>& ctxDraw, const std::vector<SamplesDraw>& samplesDraw, const std::vector<std::unique_ptr<LockDraw>>& lockDraw, int& offset, int depth, bool hasCtxSwitches, bool hasSamples );
void DrawThreadMessagesList( const TimelineContext& ctx, const std::vector<MessagesDraw>& drawList, int offset, uint64_t tid );
void DrawThreadOverlays( const ThreadData& thread, const ImVec2& ul, const ImVec2& dr );
bool DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offset );
bool DrawCpuData( const TimelineContext& ctx, const std::vector<CpuUsageDraw>& cpuDraw, const std::vector<std::vector<CpuCtxDraw>>& ctxDraw, int& offset, bool hasCpuData );
2022-09-03 14:53:02 +00:00
2020-08-09 19:11:18 +00:00
bool m_showRanges = false;
Range m_statRange;
2021-11-13 17:43:55 +00:00
Range m_waitStackRange;
2017-09-12 23:33:50 +00:00
private:
enum class ShortcutAction : uint8_t
{
None,
OpenFind
};
2018-12-16 18:58:11 +00:00
enum { InvalidId = 0xFFFFFFFF };
2021-11-13 20:28:56 +00:00
struct MemPathData
{
uint32_t cnt;
uint64_t mem;
};
enum class ViewMode
{
Paused,
LastFrames,
LastRange
};
enum class MemRange
{
Full,
Active,
Inactive
};
2022-08-28 11:17:29 +00:00
struct KeyboardNavigation
{
enum Direction
{
// Pan left / right
Left,
Right,
// Zoom in / out
In,
Out
};
2022-10-14 17:48:38 +00:00
constexpr static auto DirectionToKeyMap = std::array<ImGuiKey, 4> { ImGuiKey_A, ImGuiKey_D, ImGuiKey_W, ImGuiKey_S };
2022-08-28 11:17:29 +00:00
constexpr static auto StartRangeMod = std::array<int, 4> { -1, 1, 1, -1 };
constexpr static auto EndRangeMod = std::array<int, 4> { -1, 1, -1, 1 };
std::array<float, 4> m_scrollInertia;
};
2021-06-19 14:20:35 +00:00
struct ZoneColorData
{
uint32_t color;
uint32_t accentColor;
float thickness;
bool highlight;
};
2021-09-04 14:03:42 +00:00
struct SymList
{
uint64_t symAddr;
uint32_t incl, excl;
uint32_t count;
};
void InitMemory();
void InitTextEditor();
2018-08-17 12:44:41 +00:00
2018-04-29 23:16:08 +00:00
bool DrawImpl();
void DrawNotificationArea();
2018-11-25 18:29:20 +00:00
bool DrawConnection();
2017-09-18 00:37:25 +00:00
void DrawFrames();
2022-07-02 13:38:10 +00:00
void DrawTimelineFramesHeader();
void DrawTimelineFrames( const FrameData& frames );
void DrawTimeline();
2023-03-22 21:25:55 +00:00
void DrawSampleList( const TimelineContext& ctx, const std::vector<SamplesDraw>& drawList, const Vector<SampleData>& vec, int offset );
void DrawZoneList( const TimelineContext& ctx, const std::vector<TimelineDraw>& drawList, int offset, uint64_t tid );
void DrawContextSwitchList( const TimelineContext& ctx, const std::vector<ContextSwitchDraw>& drawList, const Vector<ContextSwitchData>& ctxSwitch, int offset, int endOffset, bool isFiber );
2019-11-02 14:52:34 +00:00
int DispatchGpuZoneLevel( const Vector<short_ptr<GpuEvent>>& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, uint64_t thread, float yMin, float yMax, int64_t begin, int drift );
2019-11-10 00:30:10 +00:00
template<typename Adapter, typename V>
int DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, uint64_t thread, float yMin, float yMax, int64_t begin, int drift );
template<typename Adapter, typename V>
int SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, uint64_t thread, float yMin, float yMax, int64_t begin, int drift );
2019-02-24 16:30:58 +00:00
void DrawLockHeader( uint32_t id, const LockMap& lockmap, const SourceLocation& srcloc, bool hover, ImDrawList* draw, const ImVec2& wpos, float w, float ty, float offset, uint8_t tid );
2023-04-15 20:47:32 +00:00
int DrawLocks( const TimelineContext& ctx, const std::vector<std::unique_ptr<LockDraw>>& lockDraw, uint64_t tid, int _offset, LockHighlight& highlight );
void DrawPlotPoint( const ImVec2& wpos, float x, float y, int offset, uint32_t color, bool hover, bool hasPrev, const PlotItem& item, double prev, PlotType type, PlotValueFormatting format, float PlotHeight, uint64_t name );
void DrawPlotPoint( const ImVec2& wpos, float x, float y, int offset, uint32_t color, bool hover, double val, PlotValueFormatting format, float PlotHeight );
2017-10-13 11:32:23 +00:00
void DrawOptions();
2017-10-14 12:36:30 +00:00
void DrawMessages();
void DrawMessageLine( const MessageData& msg, bool hasCallstack, int& idx );
void DrawFindZone();
void AccumulationModeComboBox();
2018-03-24 13:40:48 +00:00
void DrawStatistics();
void DrawSamplesStatistics(Vector<SymList>& data, int64_t timeRange, AccumulationMode accumulationMode);
void DrawMemory();
2018-09-27 21:16:10 +00:00
void DrawAllocList();
2018-04-21 22:52:33 +00:00
void DrawCompare();
void DrawCallstackWindow();
void DrawCallstackTable( uint32_t callstack, bool globalEntriesButton );
2018-07-17 21:03:03 +00:00
void DrawMemoryAllocWindow();
2018-08-08 17:25:13 +00:00
void DrawInfo();
void DrawTextEditor();
2018-12-16 18:58:11 +00:00
void DrawLockInfoWindow();
2019-06-11 23:26:49 +00:00
void DrawPlayback();
void DrawCpuDataWindow();
2019-10-13 13:50:37 +00:00
void DrawSelectedAnnotation();
2019-10-14 18:37:24 +00:00
void DrawAnnotationList();
2020-02-29 17:15:59 +00:00
void DrawSampleParents();
2020-07-31 14:37:47 +00:00
void DrawRanges();
void DrawRangeEntry( Range& range, const char* label, uint32_t color, const char* popupLabel, int id );
2021-03-27 12:25:21 +00:00
void DrawSourceTooltip( const char* filename, uint32_t line, int before = 3, int after = 3, bool separateTooltip = true );
2021-11-13 14:58:25 +00:00
void DrawWaitStacks();
2017-09-15 00:30:22 +00:00
void ListMemData( std::vector<const MemEvent*>& vec, const std::function<void(const MemEvent*)>& DrawAddress, int64_t startTime = -1, uint64_t pool = 0 );
unordered_flat_map<uint32_t, MemPathData> GetCallstackPaths( const MemData& mem, MemRange memRange ) const;
unordered_flat_map<uint64_t, MemCallstackFrameTree> GetCallstackFrameTreeBottomUp( const MemData& mem ) const;
unordered_flat_map<uint64_t, MemCallstackFrameTree> GetCallstackFrameTreeTopDown( const MemData& mem ) const;
void DrawFrameTreeLevel( const unordered_flat_map<uint64_t, MemCallstackFrameTree>& tree, int& idx );
2020-12-09 20:18:40 +00:00
void DrawZoneList( int id, const Vector<short_ptr<ZoneEvent>>& zones );
unordered_flat_map<uint64_t, CallstackFrameTree> GetCallstackFrameTreeBottomUp( const unordered_flat_map<uint32_t, uint64_t>& stacks, bool group ) const;
unordered_flat_map<uint64_t, CallstackFrameTree> GetCallstackFrameTreeTopDown( const unordered_flat_map<uint32_t, uint64_t>& stacks, bool group ) const;
2021-11-13 21:05:30 +00:00
void DrawFrameTreeLevel( const unordered_flat_map<uint64_t, CallstackFrameTree>& tree, int& idx );
unordered_flat_map<uint64_t, CallstackFrameTree> GetParentsCallstackFrameTreeBottomUp( const unordered_flat_map<uint32_t, uint32_t>& stacks, bool group ) const;
unordered_flat_map<uint64_t, CallstackFrameTree> GetParentsCallstackFrameTreeTopDown( const unordered_flat_map<uint32_t, uint32_t>& stacks, bool group ) const;
void DrawParentsFrameTreeLevel( const unordered_flat_map<uint64_t, CallstackFrameTree>& tree, int& idx );
2017-11-12 00:25:44 +00:00
void DrawInfoWindow();
void DrawZoneInfoWindow();
void DrawGpuInfoWindow();
2019-11-10 00:23:44 +00:00
template<typename Adapter, typename V>
void DrawZoneInfoChildren( const V& children, int64_t ztime );
2019-11-10 01:03:31 +00:00
template<typename Adapter, typename V>
void DrawGpuInfoChildren( const V& children, int64_t ztime );
2019-11-10 00:23:44 +00:00
void HandleRange( Range& range, int64_t timespan, const ImVec2& wpos, float w );
void HandleTimelineMouse( int64_t timespan, const ImVec2& wpos, float w );
void HandleTimelineKeyboard( int64_t timespan, const ImVec2& wpos, float w );
2017-10-12 20:27:17 +00:00
void AddAnnotation( int64_t start, int64_t end );
2019-09-11 16:34:48 +00:00
uint32_t GetThreadColor( uint64_t thread, int depth );
2019-11-02 21:45:11 +00:00
uint32_t GetSrcLocColor( const SourceLocation& srcloc, int depth );
uint32_t GetRawSrcLocColor( const SourceLocation& srcloc, int depth );
2019-09-08 12:33:30 +00:00
uint32_t GetZoneColor( const ZoneEvent& ev, uint64_t thread, int depth );
2017-11-11 21:56:05 +00:00
uint32_t GetZoneColor( const GpuEvent& ev );
2021-06-19 14:20:35 +00:00
ZoneColorData GetZoneColorData( const ZoneEvent& ev, uint64_t thread, int depth );
ZoneColorData GetZoneColorData( const GpuEvent& ev );
2017-10-01 17:31:22 +00:00
2017-10-22 13:37:24 +00:00
void ZoomToZone( const ZoneEvent& ev );
2017-11-11 21:56:05 +00:00
void ZoomToZone( const GpuEvent& ev );
void ZoomToPrevFrame();
void ZoomToNextFrame();
void CenterAtTime( int64_t t );
2018-05-02 17:23:46 +00:00
void ShowZoneInfo( const ZoneEvent& ev );
void ShowZoneInfo( const GpuEvent& ev, uint64_t thread );
2017-10-22 13:37:24 +00:00
void ZoneTooltip( const ZoneEvent& ev );
2017-11-11 21:56:05 +00:00
void ZoneTooltip( const GpuEvent& ev );
2018-06-19 20:19:33 +00:00
void CallstackTooltip( uint32_t idx );
void CallstackTooltipContents( uint32_t idx );
void CrashTooltip();
2018-06-19 20:19:33 +00:00
2017-10-22 14:15:27 +00:00
const ZoneEvent* GetZoneParent( const ZoneEvent& zone ) const;
const ZoneEvent* GetZoneParent( const ZoneEvent& zone, uint64_t tid ) const;
2022-07-23 11:31:41 +00:00
const ZoneEvent* GetZoneChild( const ZoneEvent& zone, int64_t time ) const;
bool IsZoneReentry( const ZoneEvent& zone ) const;
bool IsZoneReentry( const ZoneEvent& zone, uint64_t tid ) const;
2017-11-12 00:25:44 +00:00
const GpuEvent* GetZoneParent( const GpuEvent& zone ) const;
2019-03-17 15:17:47 +00:00
const ThreadData* GetZoneThreadData( const ZoneEvent& zone ) const;
uint64_t GetZoneThread( const ZoneEvent& zone ) const;
2018-03-19 15:11:37 +00:00
uint64_t GetZoneThread( const GpuEvent& zone ) const;
const GpuCtxData* GetZoneCtx( const GpuEvent& zone ) const;
bool FindMatchingZone( int prev0, int prev1, int flags );
const ZoneEvent* FindZoneAtTime( uint64_t thread, int64_t time ) const;
uint64_t GetFrameNumber( const FrameData& fd, int i ) const;
const char* GetFrameText( const FrameData& fd, int i, uint64_t ftime ) const;
const char* GetFrameSetName( const FrameData& fd ) const;
static const char* GetFrameSetName( const FrameData& fd, const Worker& worker );
2017-09-29 19:57:00 +00:00
#ifndef TRACY_NO_STATISTICS
void FindZones();
2018-04-21 22:52:33 +00:00
void FindZonesCompare();
#endif
std::vector<MemoryPage> GetMemoryPages() const;
2018-04-02 16:14:59 +00:00
void SmallCallstackButton( const char* name, uint32_t callstack, int& idx, bool tooltip = true );
void DrawCallstackCalls( uint32_t callstack, uint16_t limit ) const;
void SetViewToLastFrames();
2019-01-23 12:39:44 +00:00
int64_t GetZoneChildTime( const ZoneEvent& zone );
2019-02-14 00:28:12 +00:00
int64_t GetZoneChildTime( const GpuEvent& zone );
int64_t GetZoneChildTimeFast( const ZoneEvent& zone );
2020-10-02 16:37:15 +00:00
int64_t GetZoneChildTimeFastClamped( const ZoneEvent& zone, int64_t t0, int64_t t1 );
2019-03-29 23:52:25 +00:00
int64_t GetZoneSelfTime( const ZoneEvent& zone );
int64_t GetZoneSelfTime( const GpuEvent& zone );
bool GetZoneRunningTime( const ContextSwitch* ctx, const ZoneEvent& ev, int64_t& time, uint64_t& cnt );
2020-05-03 12:21:27 +00:00
const char* GetThreadContextData( uint64_t thread, bool& local, bool& untracked, const char*& program );
2018-07-17 20:53:38 +00:00
tracy_force_inline void CalcZoneTimeData( unordered_flat_map<int16_t, ZoneTimeData>& data, int64_t& ztime, const ZoneEvent& zone );
tracy_force_inline void CalcZoneTimeData( const ContextSwitch* ctx, unordered_flat_map<int16_t, ZoneTimeData>& data, int64_t& ztime, const ZoneEvent& zone );
template<typename Adapter, typename V>
void CalcZoneTimeDataImpl( const V& children, unordered_flat_map<int16_t, ZoneTimeData>& data, int64_t& ztime );
template<typename Adapter, typename V>
void CalcZoneTimeDataImpl( const V& children, const ContextSwitch* ctx, unordered_flat_map<int16_t, ZoneTimeData>& data, int64_t& ztime );
2019-06-12 22:12:06 +00:00
void SetPlaybackFrame( uint32_t idx );
bool Save( const char* fn, FileWrite::Compression comp, int zlevel, bool buildDict );
2019-06-12 22:12:06 +00:00
2022-10-13 18:36:54 +00:00
void Attention( bool& alreadyDone );
void UpdateTitle();
2022-10-13 18:36:54 +00:00
unordered_flat_map<uint64_t, bool> m_visibleMsgThread;
unordered_flat_map<uint64_t, bool> m_waitStackThread;
unordered_flat_map<const void*, int> m_gpuDrift;
unordered_flat_map<const PlotData*, PlotView> m_plotView;
Vector<const ThreadData*> m_threadOrder;
2019-07-11 18:28:04 +00:00
Vector<float> m_threadDnd;
2018-08-18 17:57:36 +00:00
tracy_force_inline bool& VisibleMsgThread( uint64_t thread )
{
auto it = m_visibleMsgThread.find( thread );
if( it == m_visibleMsgThread.end() )
{
it = m_visibleMsgThread.emplace( thread, true ).first;
}
return it->second;
}
tracy_force_inline bool& WaitStackThread( uint64_t thread )
{
auto it = m_waitStackThread.find( thread );
if( it == m_waitStackThread.end() )
{
it = m_waitStackThread.emplace( thread, true ).first;
}
return it->second;
}
2018-06-27 23:08:08 +00:00
tracy_force_inline int& GpuDrift( const void* ptr )
{
auto it = m_gpuDrift.find( ptr );
if( it == m_gpuDrift.end() )
{
it = m_gpuDrift.emplace( ptr, 0 ).first;
}
return it->second;
}
2022-07-02 11:16:06 +00:00
static int64_t AdjustGpuTime( int64_t time, int64_t begin, int drift );
2020-04-12 21:41:18 +00:00
2022-07-02 11:35:47 +00:00
static const char* DecodeContextSwitchState( uint8_t state );
static const char* DecodeContextSwitchStateCode( uint8_t state );
static const char* DecodeContextSwitchReason( uint8_t reason );
static const char* DecodeContextSwitchReasonCode( uint8_t reason );
Worker m_worker;
std::string m_filename, m_filenameStaging;
2017-09-30 14:58:02 +00:00
bool m_staticView;
ViewMode m_viewMode;
bool m_viewModeHeuristicTry = false;
DecayValue<bool> m_forceConnectionPopup = false;
uint64_t m_totalMemory;
2017-09-20 19:21:21 +00:00
ViewData m_vd;
TimelineController m_tc;
KeyboardNavigation m_kbNavCtrl;
const ZoneEvent* m_zoneInfoWindow = nullptr;
2017-10-22 13:37:24 +00:00
const ZoneEvent* m_zoneHighlight;
DecayValue<int16_t> m_zoneSrcLocHighlight = 0;
LockHighlight m_lockHighlight { -1 };
LockHighlight m_nextLockHighlight;
DecayValue<const MessageData*> m_msgHighlight = nullptr;
2019-02-17 15:20:56 +00:00
DecayValue<uint32_t> m_lockHoverHighlight = InvalidId;
DecayValue<const MessageData*> m_msgToFocus = nullptr;
const GpuEvent* m_gpuInfoWindow = nullptr;
2017-11-12 00:28:07 +00:00
const GpuEvent* m_gpuHighlight;
2017-11-13 23:48:26 +00:00
uint64_t m_gpuInfoWindowThread;
uint32_t m_callstackInfoWindow = 0;
int64_t m_memoryAllocInfoWindow = -1;
2020-09-25 15:51:05 +00:00
uint64_t m_memoryAllocInfoPool = 0;
int64_t m_memoryAllocHover = -1;
2020-09-25 15:51:05 +00:00
uint64_t m_memoryAllocHoverPool = 0;
int m_memoryAllocHoverWait = 0;
2018-08-04 17:47:09 +00:00
const FrameData* m_frames;
uint32_t m_lockInfoWindow = InvalidId;
2019-11-02 15:17:20 +00:00
const ZoneEvent* m_zoneHover = nullptr;
DecayValue<const ZoneEvent*> m_zoneHover2 = nullptr;
int m_frameHover = -1;
2019-07-12 23:25:37 +00:00
bool m_messagesScrollBottom;
2019-07-12 23:48:43 +00:00
ImGuiTextFilter m_messageFilter;
bool m_showMessageImages = false;
int m_visibleMessages = 0;
size_t m_prevMessages = 0;
bool m_messagesShowCallstack = false;
Vector<uint32_t> m_msgList;
2019-08-01 21:14:09 +00:00
bool m_disconnectIssued = false;
DecayValue<uint64_t> m_drawThreadMigrations = 0;
DecayValue<uint64_t> m_drawThreadHighlight = 0;
2019-10-13 13:50:37 +00:00
Annotation* m_selectedAnnotation = nullptr;
2020-05-23 14:40:15 +00:00
bool m_reactToCrash = false;
2020-11-18 00:23:46 +00:00
bool m_reactToLostConnection = false;
2017-10-13 11:32:23 +00:00
ImGuiTextFilter m_statisticsFilter;
ImGuiTextFilter m_statisticsImageFilter;
ImGuiTextFilter m_userTextFilter;
unordered_flat_set<Worker::ZoneThreadData*> m_filteredZones;
Region m_highlight;
Region m_highlightZoom;
2019-11-24 00:40:32 +00:00
DecayValue<uint64_t> m_cpuDataThread = 0;
uint64_t m_gpuThread = 0;
int64_t m_gpuStart = 0;
int64_t m_gpuEnd = 0;
bool m_showOptions = false;
bool m_showMessages = false;
bool m_showStatistics = false;
bool m_showInfo = false;
2019-06-11 23:26:49 +00:00
bool m_showPlayback = false;
bool m_showCpuDataWindow = false;
2019-10-14 18:37:24 +00:00
bool m_showAnnotationList = false;
2021-11-13 14:58:25 +00:00
bool m_showWaitStacks = false;
AccumulationMode m_statAccumulationMode = AccumulationMode::SelfOnly;
2020-02-27 01:08:20 +00:00
bool m_statSampleTime = true;
2020-02-27 11:24:28 +00:00
int m_statMode = 0;
int m_statSampleLocation = 2;
bool m_statHideUnknown = true;
bool m_showAllSymbols = false;
int m_showCallstackFrameAddress = 0;
bool m_showUnknownFrames = true;
2020-04-09 17:44:42 +00:00
bool m_statSeparateInlines = false;
bool m_statShowAddress = false;
bool m_statShowKernel = true;
bool m_groupChildrenLocations = false;
bool m_allocTimeRelativeToZone = true;
bool m_ctxSwitchTimeRelativeToZone = true;
bool m_messageTimeRelativeToZone = true;
bool m_messagesExcludeChildren = true;
uint64_t m_zoneInfoMemPool = 0;
2021-11-13 14:58:25 +00:00
int m_waitStack = 0;
2021-11-13 20:54:04 +00:00
int m_waitStackMode = 0;
bool m_groupWaitStackBottomUp = true;
bool m_groupWaitStackTopDown = true;
ShortcutAction m_shortcut = ShortcutAction::None;
ShortenName m_shortenName = ShortenName::NoSpaceAndNormalize;
2017-11-27 21:41:30 +00:00
Animation m_zoomAnim;
BuzzAnim<int> m_callstackBuzzAnim;
2020-02-29 17:15:59 +00:00
BuzzAnim<int> m_sampleParentBuzzAnim;
BuzzAnim<int> m_callstackTreeBuzzAnim;
2018-08-18 12:26:10 +00:00
BuzzAnim<const void*> m_zoneinfoBuzzAnim;
BuzzAnim<int> m_findZoneBuzzAnim;
BuzzAnim<int16_t> m_optionsLockBuzzAnim;
2018-12-16 18:58:11 +00:00
BuzzAnim<uint32_t> m_lockInfoAnim;
BuzzAnim<uint32_t> m_statBuzzAnim;
2017-10-22 11:56:05 +00:00
2018-05-02 17:23:46 +00:00
Vector<const ZoneEvent*> m_zoneInfoStack;
Vector<const GpuEvent*> m_gpuInfoStack;
2021-03-27 12:25:21 +00:00
SourceContents m_srcHintCache;
std::unique_ptr<SourceView> m_sourceView;
const char* m_sourceViewFile;
bool m_uarchSet = false;
2018-08-17 12:44:41 +00:00
2019-08-16 14:02:57 +00:00
ImFont* m_smallFont;
2019-07-12 17:16:56 +00:00
ImFont* m_bigFont;
2021-03-27 12:16:19 +00:00
ImFont* m_fixedFont;
2019-07-12 17:16:56 +00:00
float m_rootWidth, m_rootHeight;
SetTitleCallback m_stcb;
bool m_titleSet = false;
SetScaleCallback m_sscb;
2022-10-13 17:31:47 +00:00
AttentionCallback m_acb;
float m_notificationTime = 0;
std::string m_notificationText;
bool m_groupCallstackTreeByNameBottomUp = true;
bool m_groupCallstackTreeByNameTopDown = true;
MemRange m_memRangeBottomUp = MemRange::Full;
MemRange m_memRangeTopDown = MemRange::Full;
2019-02-06 20:45:26 +00:00
enum class SaveThreadState
{
Inert,
Saving,
NeedsJoin
};
enum
{
FindMatchingZoneFlagDefault = 0,
FindMatchingZoneFlagSourceFile = (1 << 0),
FindMatchingZoneFlagLineNum = (1 << 1),
};
2019-06-02 11:15:55 +00:00
std::atomic<SaveThreadState> m_saveThreadState { SaveThreadState::Inert };
std::thread m_saveThread;
2020-02-08 12:07:02 +00:00
std::atomic<size_t> m_srcFileBytes { 0 };
std::atomic<size_t> m_dstFileBytes { 0 };
2019-06-06 21:14:49 +00:00
void* m_frameTexture = nullptr;
2019-06-06 21:10:01 +00:00
const void* m_frameTexturePtr = nullptr;
2019-06-06 20:14:25 +00:00
void* m_frameTextureConn = nullptr;
const void* m_frameTextureConnPtr = nullptr;
2019-10-13 13:28:52 +00:00
std::vector<std::unique_ptr<Annotation>> m_annotations;
2019-07-26 21:05:24 +00:00
UserData m_userData;
bool m_wasActive = false;
bool m_reconnectRequested = false;
bool m_firstFrame = true;
std::chrono::time_point<std::chrono::high_resolution_clock> m_firstFrameTime;
2020-08-05 15:20:19 +00:00
float m_yDelta;
std::vector<SourceRegex> m_sourceSubstitutions;
bool m_sourceRegexValid = true;
RangeSlim m_setRangePopup;
2020-08-04 14:49:39 +00:00
bool m_setRangePopupOpen = false;
2020-11-01 15:24:08 +00:00
unordered_flat_map<int16_t, StatisticsCache> m_statCache;
2022-01-29 14:35:25 +00:00
unordered_flat_map<int16_t, StatisticsCache> m_gpuStatCache;
2020-11-01 15:24:08 +00:00
unordered_flat_map<const void*, bool> m_visMap;
void(*m_cbMainThread)(const std::function<void()>&, bool);
2022-09-04 11:37:19 +00:00
int m_gpuIdx = 0;
struct FindZone {
enum : uint64_t { Unselected = std::numeric_limits<uint64_t>::max() - 1 };
2020-07-04 10:36:04 +00:00
enum class GroupBy : int { Thread, UserText, ZoneName, Callstack, Parent, NoGrouping };
enum class SortBy : int { Order, Count, Time, Mtpc };
2018-07-21 21:53:11 +00:00
struct Group
{
2020-01-20 22:40:07 +00:00
uint16_t id;
Vector<short_ptr<ZoneEvent>> zones;
Vector<uint16_t> zonesTids;
2018-07-21 21:53:11 +00:00
int64_t time = 0;
};
2018-04-01 19:24:30 +00:00
bool show = false;
bool ignoreCase = false;
std::vector<int16_t> match;
unordered_flat_map<uint64_t, Group> groups;
size_t processed;
2020-01-20 22:40:07 +00:00
uint16_t groupId;
int selMatch = 0;
uint64_t selGroup = Unselected;
2018-04-01 19:24:30 +00:00
char pattern[1024] = {};
bool logVal = false;
bool logTime = true;
2018-03-05 19:15:18 +00:00
bool cumulateTime = false;
bool selfTime = false;
bool runningTime = false;
GroupBy groupBy = GroupBy::Thread;
SortBy sortBy = SortBy::Count;
2018-03-04 21:52:36 +00:00
Region highlight;
int64_t hlOrig_t0, hlOrig_t1;
2018-06-06 21:06:00 +00:00
int64_t numBins = -1;
std::unique_ptr<int64_t[]> bins, binTime, selBin;
2020-01-20 22:58:36 +00:00
Vector<int64_t> sorted, selSort;
size_t sortedNum = 0, selSortNum, selSortActive;
float average, selAverage;
float median, selMedian;
int64_t total, selTotal;
2019-12-28 14:48:45 +00:00
int64_t selTime;
bool drawAvgMed = true;
bool drawSelAvgMed = true;
bool scheduleResetMatch = false;
int selCs = 0;
int minBinVal = 1;
int64_t tmin, tmax;
bool showZoneInFrames = false;
Range range;
RangeSlim rangeSlim;
2018-03-04 21:52:36 +00:00
struct
{
int numBins = -1;
ptrdiff_t distBegin;
ptrdiff_t distEnd;
} binCache;
struct {
Vector<SymList> counts;
bool scheduleUpdate = false;
bool enabled = false;
} samples;
2018-03-04 21:52:36 +00:00
void Reset()
{
ResetMatch();
2018-03-04 21:52:36 +00:00
match.clear();
selMatch = 0;
selGroup = Unselected;
2018-03-04 21:52:36 +00:00
highlight.active = false;
samples.counts.clear();
}
void ResetMatch()
{
ResetGroups();
sorted.clear();
sortedNum = 0;
average = 0;
median = 0;
total = 0;
2019-08-14 19:53:09 +00:00
tmin = std::numeric_limits<int64_t>::max();
tmax = std::numeric_limits<int64_t>::min();
2018-03-04 21:52:36 +00:00
}
void ResetGroups()
{
ResetSelection();
groups.clear();
processed = 0;
2020-01-20 22:40:07 +00:00
groupId = 0;
selCs = 0;
selGroup = Unselected;
}
void ResetSelection()
{
selSort.clear();
selSortNum = 0;
selSortActive = 0;
selAverage = 0;
selMedian = 0;
selTotal = 0;
2019-12-28 14:48:45 +00:00
selTime = 0;
binCache.numBins = -1;
samples.scheduleUpdate = true;
}
void ShowZone( int16_t srcloc, const char* name )
{
show = true;
range.active = false;
Reset();
match.emplace_back( srcloc );
strcpy( pattern, name );
}
void ShowZone( int16_t srcloc, const char* name, int64_t limitMin, int64_t limitMax )
{
assert( limitMin <= limitMax );
show = true;
range.active = true;
range.min = limitMin;
range.max = limitMax;
Reset();
match.emplace_back( srcloc );
strcpy( pattern, name );
}
} m_findZone;
2018-04-01 19:24:30 +00:00
tracy_force_inline uint64_t GetSelectionTarget( const Worker::ZoneThreadData& ev, FindZone::GroupBy groupBy ) const;
2018-06-06 21:09:46 +00:00
struct CompVal
{
double v0;
double v1;
};
2018-04-21 22:52:33 +00:00
struct {
bool show = false;
bool ignoreCase = false;
bool link = true;
2018-04-21 22:52:33 +00:00
std::unique_ptr<Worker> second;
std::unique_ptr<UserData> userData;
std::thread loadThread;
2019-08-12 10:04:27 +00:00
BadVersionState badVer;
2018-04-21 22:52:33 +00:00
char pattern[1024] = {};
std::vector<int16_t> match[2];
2018-04-21 22:52:33 +00:00
int selMatch[2] = { 0, 0 };
bool logVal = false;
bool logTime = true;
bool cumulateTime = false;
bool normalize = true;
2018-06-06 21:09:46 +00:00
int64_t numBins = -1;
std::unique_ptr<CompVal[]> bins, binTime;
std::vector<int64_t> sorted[2];
size_t sortedNum[2] = { 0, 0 };
float average[2];
float median[2];
int64_t total[2];
int minBinVal = 1;
2019-09-16 19:51:36 +00:00
int compareMode = 0;
bool diffDone = false;
bool diffDirection;
std::vector<const char*> thisUnique;
std::vector<const char*> secondUnique;
2022-12-23 17:48:05 +00:00
std::vector<std::pair<const char*, std::string>> diffs;
void ResetSelection()
{
for( int i=0; i<2; i++ )
{
sorted[i].clear();
sortedNum[i] = 0;
average[i] = 0;
median[i] = 0;
total[i] = 0;
}
}
2018-04-21 22:52:33 +00:00
void Reset()
{
ResetSelection();
2018-04-21 22:52:33 +00:00
for( int i=0; i<2; i++ )
{
match[i].clear();
selMatch[i] = 0;
}
diffDone = false;
thisUnique.clear();
secondUnique.clear();
2022-12-23 17:48:05 +00:00
diffs.clear();
2018-04-21 22:52:33 +00:00
}
} m_compare;
2018-04-01 19:24:30 +00:00
struct {
bool show = false;
char pattern[1024] = {};
uint64_t ptrFind = 0;
2020-09-25 15:51:05 +00:00
uint64_t pool = 0;
2018-09-27 21:16:10 +00:00
bool showAllocList = false;
std::vector<size_t> allocList;
2021-11-29 17:17:19 +00:00
Range range;
2018-04-01 19:24:30 +00:00
} m_memInfo;
struct {
2018-08-31 23:02:08 +00:00
std::vector<int64_t> data;
const FrameData* frameSet = nullptr;
size_t frameNum = 0;
float average = 0;
float median = 0;
2018-08-31 23:12:04 +00:00
int64_t total = 0;
2018-08-31 23:12:16 +00:00
bool logVal = false;
bool logTime = true;
int64_t numBins = -1;
std::unique_ptr<int64_t[]> bins;
bool drawAvgMed = true;
bool limitToView = false;
std::pair<int, int> limitRange = { -1, 0 };
int minBinVal = 1;
} m_frameSortData;
2019-03-29 23:52:25 +00:00
struct {
std::pair<const ZoneEvent*, int64_t> zoneSelfTime = { nullptr, 0 };
std::pair<const ZoneEvent*, int64_t> zoneSelfTime2 = { nullptr, 0 };
2019-03-29 23:52:25 +00:00
std::pair<const GpuEvent*, int64_t> gpuSelfTime = { nullptr, 0 };
std::pair<const GpuEvent*, int64_t> gpuSelfTime2 = { nullptr, 0 };
2019-03-29 23:52:25 +00:00
} m_cache;
2019-06-11 23:26:49 +00:00
struct {
void* texture = nullptr;
float timeLeft = 0;
float speed = 1;
uint32_t frame = 0;
uint32_t currFrame = -1;
bool pause = true;
bool sync = false;
bool zoom = false;
2019-06-11 23:26:49 +00:00
} m_playback;
struct TimeDistribution {
bool runningTime = false;
bool exclusiveTime = true;
unordered_flat_map<int16_t, ZoneTimeData> data;
2019-10-20 01:24:58 +00:00
const ZoneEvent* dataValidFor = nullptr;
float fztime;
} m_timeDist;
2020-02-29 17:15:59 +00:00
struct {
uint64_t symAddr = 0;
int sel;
bool withInlines = false;
int mode = 0;
bool groupBottomUp = true;
bool groupTopDown = true;
2020-02-29 17:15:59 +00:00
} m_sampleParents;
2022-07-03 12:52:18 +00:00
struct
{
bool enabled = false;
bool monitor = false;
int64_t time;
} m_sendQueueWarning;
2022-10-13 18:39:43 +00:00
bool m_attnProtoMismatch = false;
bool m_attnNotAvailable = false;
bool m_attnDropped = false;
bool m_attnFailure = false;
bool m_attnWorking = false;
2022-10-13 18:49:30 +00:00
bool m_attnDisconnected = false;
2017-09-12 23:33:50 +00:00
};
}
#endif