Eliminate the function GetZoneCtx

Eric Eaton · Eric Eaton · commit eaa7f8060671 · 2025-10-09T13:17:04.000-07:00
The function GetZoneCtx isn't needed. This patch introduces a small
structure to help transport the context around to avoid the expensive
search. The GPU timeline function take the context as a parameter now
instead of the thread ID, since the supplied thread ID is derived from
the context in every invocation.
diff --git a/profiler/src/profiler/TracyView.hpp b/profiler/src/profiler/TracyView.hpp
@@ -255,11 +255,11 @@ class View
     void DrawZoneList( const TimelineContext& ctx, const std::vector<TimelineDraw>& drawList, int offset, uint64_t tid, int maxDepth, double margin );
     void DrawThreadCropper( const int depth, const uint64_t tid, const float xPos, const float yPos, const float ostep, const float cropperWidth, const bool hasCtxSwitches );
     void DrawContextSwitchList( const TimelineContext& ctx, const std::vector<ContextSwitchDraw>& drawList, const Vector<ContextSwitchData>& ctxSwitch, int offset, int endOffset, bool isFiber );
-    int DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& 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 );
+    int DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift );
     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 );
+    int DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, const GpuCtxData* ctx, 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 );
+    int SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift );
     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 );
     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 );
@@ -320,7 +320,7 @@ class View
     template<typename Adapter, typename V>
     void DrawZoneInfoChildren( const V& children, int64_t ztime );
     template<typename Adapter, typename V>
-    void DrawGpuInfoChildren( const V& children, int64_t ztime );
+    void DrawGpuInfoChildren( const V& children, int64_t ztime, const GpuCtxData* ctx );
 
     void HandleRange( Range& range, int64_t timespan, const ImVec2& wpos, float w );
     void HandleTimelineMouse( int64_t timespan, const ImVec2& wpos, float w );
@@ -338,16 +338,16 @@ class View
     ZoneColorData GetZoneColorData( const ZoneEvent& ev );
 
     void ZoomToZone( const ZoneEvent& ev );
-    void ZoomToZoneGPU( const ZoneEvent& ev );
+    void ZoomToZoneGPU( const ZoneEventC ev );
     void ZoomToPrevFrame();
     void ZoomToNextFrame();
     void CenterAtTime( int64_t t );
 
     void ShowZoneInfo( const ZoneEvent& ev );
-    void ShowZoneInfo( const ZoneEvent& ev, uint64_t thread );
+    void ShowZoneInfo( const ZoneEventC ev, uint64_t thread );
 
     void ZoneTooltip( const ZoneEvent& ev );
-    void ZoneTooltipGPU( const ZoneEvent& ev );
+    void ZoneTooltipGPU( const ZoneEventC ev );
     void CallstackTooltip( uint32_t idx );
     void CallstackTooltipContents( uint32_t idx );
     void CrashTooltip();
@@ -357,11 +357,10 @@ class View
     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;
-    const ZoneEvent* GetZoneParentGPU( const ZoneEvent& zone ) const;
+    ZoneEventC GetZoneParentGPU( const ZoneEventC zone ) const;
     const ThreadData* GetZoneThreadData( const ZoneEvent& zone ) const;
     uint64_t GetZoneThread( const ZoneEvent& zone ) const;
     uint64_t GetZoneThreadGPU( const EventAdapter<true>& zone ) const;
-    const GpuCtxData* GetZoneCtx( const ZoneEvent& 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;
@@ -477,7 +476,7 @@ class View
     DecayValue<const MessageData*> m_msgHighlight = nullptr;
     DecayValue<uint32_t> m_lockHoverHighlight = InvalidId;
     DecayValue<const MessageData*> m_msgToFocus = nullptr;
-    const ZoneEvent* m_gpuInfoWindow = nullptr;
+    ZoneEventC m_gpuInfoWindow = {nullptr, nullptr};
     const ZoneEvent* m_gpuHighlight;
     uint64_t m_gpuInfoWindowThread;
     uint32_t m_callstackInfoWindow = 0;
@@ -573,7 +572,7 @@ class View
     BuzzAnim<uint32_t> m_statBuzzAnim;
 
     Vector<const ZoneEvent*> m_zoneInfoStack;
-    Vector<const ZoneEvent*> m_gpuInfoStack;
+    Vector<ZoneEventC> m_gpuInfoStack;
 
     SourceContents m_srcHintCache;
     std::unique_ptr<SourceView> m_sourceView;
diff --git a/profiler/src/profiler/TracyView_GpuTimeline.cpp b/profiler/src/profiler/TracyView_GpuTimeline.cpp
@@ -46,7 +46,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs
                 const auto begin = tlm.front().Start();
                 const auto drift = GpuDrift( &gpu );
                 if( !singleThread ) offset += sstep;
-                const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, gpu.thread, yMin, yMax, begin, drift );
+                const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, &gpu, yMin, yMax, begin, drift );
                 if( partDepth != 0 )
                 {
                     if( !singleThread )
@@ -73,7 +73,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs
                 const auto begin = tl.front()->Start();
                 const auto drift = GpuDrift( &gpu );
                 if( !singleThread ) offset += sstep;
-                const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, gpu.thread, yMin, yMax, begin, drift );
+                const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, &gpu, yMin, yMax, begin, drift );
                 if( partDepth != 0 )
                 {
                     if( !singleThread )
@@ -97,7 +97,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs
     return depth != 0;
 }
 
-int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& 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 )
+int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData *ctx, float yMin, float yMax, int64_t begin, int drift )
 {
     const auto ty = ImGui::GetTextLineHeight();
     const auto ostep = ty + 1;
@@ -108,28 +108,28 @@ int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& vec, bool ho
     {
         if( vec.is_magic() )
         {
-            return DrawGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( *(Vector<ZoneEvent>*)&vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+            return DrawGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( *(Vector<ZoneEvent>*)&vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
         }
         else
         {
-            return DrawGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+            return DrawGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
         }
     }
     else
     {
         if( vec.is_magic() )
         {
-            return SkipGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( *(Vector<ZoneEvent>*)&vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+            return SkipGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( *(Vector<ZoneEvent>*)&vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
         }
         else
         {
-            return SkipGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+            return SkipGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
         }
     }
 }
 
 template<typename Adapter, typename V>
-int View::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 )
+int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift )
 {
     // cast to uint64_t, so that unended zones (end = -1) are still drawn
     auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, m_vd.zvStart ), [begin, drift] ( const auto& l, const auto& r ) { Adapter a; return (uint64_t)AdjustGpuTime( a(l).End(), begin, drift ) < (uint64_t)r; } );
@@ -159,6 +159,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
         const auto start = AdjustGpuTime( ev.GpuStart(), begin, drift );
         end = AdjustGpuTime( end, begin, drift );
         const auto zsz = std::max( ( end - start ) * pxns, pxns * 0.5 );
+        const auto zoneThread = ctx->thread != 0 ? ctx->thread : m_worker.DecompressThread( ev.Thread() );
         if( zsz < MinVisSize )
         {
             const auto color = GetZoneColor( ev );
@@ -202,16 +203,15 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
                 }
                 else
                 {
-                    const auto zoneThread = thread != 0 ? thread : m_worker.DecompressThread( ev.Thread() );
-                    ZoneTooltipGPU( ev );
+                    ZoneTooltipGPU( { &ev.event, ctx } );
 
                     if( IsMouseClicked( 2 ) && rend - start > 0 )
                     {
-                        ZoomToZoneGPU( ev );
+                        ZoomToZoneGPU( { &ev.event, ctx } );
                     }
                     if( IsMouseClicked( 0 ) )
                     {
-                        ShowZoneInfo( ev, zoneThread );
+                        ShowZoneInfo( { &ev.event, ctx }, zoneThread );
                     }
 
                     m_gpuThread = zoneThread;
@@ -231,7 +231,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
         {
             if( ev.Child() >= 0 )
             {
-                const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+                const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
                 if( d > maxdepth ) maxdepth = d;
             }
 
@@ -288,16 +288,15 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
 
             if( hover && ImGui::IsMouseHoveringRect( wpos + ImVec2( px0, offset ), wpos + ImVec2( px1, offset + tsz.y + 1 ) ) )
             {
-                const auto zoneThread = thread != 0 ? thread : m_worker.DecompressThread( ev.thread );
-                ZoneTooltipGPU( ev );
+                ZoneTooltipGPU( { &ev.event, ctx } );
 
                 if( !m_zoomAnim.active && IsMouseClicked( 2 ) )
                 {
-                    ZoomToZoneGPU( ev );
+                    ZoomToZoneGPU( { &ev.event, ctx } );
                 }
                 if( IsMouseClicked( 0 ) )
                 {
-                    ShowZoneInfo( ev, zoneThread );
+                    ShowZoneInfo( { &ev.event, ctx }, zoneThread );
                 }
 
                 m_gpuThread = zoneThread;
@@ -312,7 +311,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
 }
 
 template<typename Adapter, typename V>
-int View::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 )
+int View::SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift )
 {
     // cast to uint64_t, so that unended zones (end = -1) are still drawn
     auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, m_vd.zvStart ), [begin, drift] ( const auto& l, const auto& r ) { Adapter a; return (uint64_t)AdjustGpuTime( a(l).End(), begin, drift ) < (uint64_t)r; } );
@@ -357,7 +356,7 @@ int View::SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,
         {
             if( ev.Child() >= 0 )
             {
-                const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );
+                const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );
                 if( d > maxdepth ) maxdepth = d;
             }
             ++it;
diff --git a/profiler/src/profiler/TracyView_Navigation.cpp b/profiler/src/profiler/TracyView_Navigation.cpp
@@ -10,11 +10,12 @@ void View::ZoomToZone( const ZoneEvent& ev )
     ZoomToRange( ev.Start(), end );
 }
 
-void View::ZoomToZoneGPU( const ZoneEvent& ev )
+void View::ZoomToZoneGPU( const ZoneEventC evC )
 {
+    auto& ev = *evC.event;
+    auto ctx = evC.ctx;
     const auto end = m_worker.GetZoneEndGPU( ev );
     if( end - ev.Start() <= 0 ) return;
-    auto ctx = GetZoneCtx( ev );
     if( !ctx )
     {
         ZoomToRange( ev.Start(), end );
diff --git a/profiler/src/profiler/TracyView_Timeline.cpp b/profiler/src/profiler/TracyView_Timeline.cpp
@@ -473,7 +473,7 @@ void View::DrawTimeline()
     }
     if( m_gpuInfoWindow )
     {
-        const auto ex = m_worker.GetGpuExtra( *m_gpuInfoWindow );
+        const auto ex = m_worker.GetGpuExtra( *m_gpuInfoWindow.event );
         const auto px0 = ( ex.CpuStart() - m_vd.zvStart ) * pxns;
         const auto px1 = std::max( px0 + std::max( 1.0, pxns * 0.5 ), ( ex.CpuEnd() - m_vd.zvStart ) * pxns );
         draw->AddRectFilled( ImVec2( wpos.x + px0, linepos.y ), ImVec2( wpos.x + px1, linepos.y + lineh ), 0x2288DD88 );
diff --git a/profiler/src/profiler/TracyView_Utility.cpp b/profiler/src/profiler/TracyView_Utility.cpp
@@ -395,42 +395,41 @@ bool View::IsZoneReentry( const ZoneEvent& zone, uint64_t tid ) const
     return false;
 }
 
-const ZoneEvent* View::GetZoneParentGPU( const ZoneEvent& zone ) const
+ZoneEventC View::GetZoneParentGPU( const ZoneEventC zoneC ) const
 {
-    for( const auto& ctx : m_worker.GetGpuData() )
+    auto& zone = *zoneC.event;
+    auto ctx = zoneC.ctx;
+    for( const auto& td : ctx->threadData )
     {
-        for( const auto& td : ctx->threadData )
+        const ZoneEvent* parent = nullptr;
+        const Vector<short_ptr<ZoneEvent>>* timeline = &td.second.timeline;
+        if( timeline->empty() ) continue;
+        for(;;)
         {
-            const ZoneEvent* parent = nullptr;
-            const Vector<short_ptr<ZoneEvent>>* timeline = &td.second.timeline;
-            if( timeline->empty() ) continue;
-            for(;;)
+            if( timeline->is_magic() )
             {
-                if( timeline->is_magic() )
-                {
-                    auto vec = (Vector<ZoneEvent>*)timeline;
-                    auto it = std::upper_bound( vec->begin(), vec->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r.Start(); } );
-                    if( it != vec->begin() ) --it;
-                    if( zone.End() >= 0 && it->Start() > zone.End() ) break;
-                    if( it == &zone ) return parent;
-                    if( it->Child() < 0 ) break;
-                    parent = it;
-                    timeline = &m_worker.GetGpuChildren( parent->Child() );
-                }
-                else
-                {
-                    auto it = std::upper_bound( timeline->begin(), timeline->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r->Start(); } );
-                    if( it != timeline->begin() ) --it;
-                    if( zone.End() >= 0 && (*it)->Start() > zone.End() ) break;
-                    if( *it == &zone ) return parent;
-                    if( (*it)->Child() < 0 ) break;
-                    parent = *it;
-                    timeline = &m_worker.GetGpuChildren( parent->Child() );
-                }
+                auto vec = (Vector<ZoneEvent>*)timeline;
+                auto it = std::upper_bound( vec->begin(), vec->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r.Start(); } );
+                if( it != vec->begin() ) --it;
+                if( zone.End() >= 0 && it->Start() > zone.End() ) break;
+                if( it == &zone ) return { parent, ctx };
+                if( it->Child() < 0 ) break;
+                parent = it;
+                timeline = &m_worker.GetGpuChildren( parent->Child() );
+            }
+            else
+            {
+                auto it = std::upper_bound( timeline->begin(), timeline->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r->Start(); } );
+                if( it != timeline->begin() ) --it;
+                if( zone.End() >= 0 && (*it)->Start() > zone.End() ) break;
+                if( *it == &zone ) return { parent, ctx };
+                if( (*it)->Child() < 0 ) break;
+                parent = *it;
+                timeline = &m_worker.GetGpuChildren( parent->Child() );
             }
         }
     }
-    return nullptr;
+    return { nullptr, nullptr };
 }
 
 const ThreadData* View::GetZoneThreadData( const ZoneEvent& zone ) const
@@ -526,41 +525,6 @@ uint64_t View::GetZoneThreadGPU( const EventAdapter<true>& zone ) const
     }
 }
 
-const GpuCtxData* View::GetZoneCtx( const ZoneEvent& zone ) const
-{
-    for( const auto& ctx : m_worker.GetGpuData() )
-    {
-        for( const auto& td : ctx->threadData )
-        {
-            const Vector<short_ptr<ZoneEvent>>* timeline = &td.second.timeline;
-            if( timeline->empty() ) continue;
-            for(;;)
-            {
-                if( timeline->is_magic() )
-                {
-                    auto vec = (Vector<ZoneEvent>*)timeline;
-                    auto it = std::upper_bound( vec->begin(), vec->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r.Start(); } );
-                    if( it != vec->begin() ) --it;
-                    if( zone.End() >= 0 && it->Start() > zone.End() ) break;
-                    if( it == &zone ) return ctx;
-                    if( it->Child() < 0 ) break;
-                    timeline = &m_worker.GetGpuChildren( it->Child() );
-                }
-                else
-                {
-                    auto it = std::upper_bound( timeline->begin(), timeline->end(), zone.Start(), [] ( const auto& l, const auto& r ) { return (uint64_t)l < (uint64_t)r->Start(); } );
-                    if( it != timeline->begin() ) --it;
-                    if( zone.End() >= 0 && (*it)->Start() > zone.End() ) break;
-                    if( *it == &zone ) return ctx;
-                    if( (*it)->Child() < 0 ) break;
-                    timeline = &m_worker.GetGpuChildren( (*it)->Child() );
-                }
-            }
-        }
-    }
-    return nullptr;
-}
-
 int64_t View::GetZoneChildTime( const ZoneEvent& zone, bool gpu )
 {
     int64_t time = 0;
diff --git a/profiler/src/profiler/TracyView_ZoneInfo.cpp b/profiler/src/profiler/TracyView_ZoneInfo.cpp
diff --git a/server/TracyEvent.hpp b/server/TracyEvent.hpp

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs`
`46`	`46`	`const auto begin = tlm.front().Start();`
`47`	`47`	`const auto drift = GpuDrift( &gpu );`
`48`	`48`	`if( !singleThread ) offset += sstep;`
`49`		`- const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, gpu.thread, yMin, yMax, begin, drift );`
	`49`	`+ const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, &gpu, yMin, yMax, begin, drift );`
`50`	`50`	`if( partDepth != 0 )`
`51`	`51`	`{`
`52`	`52`	`if( !singleThread )`
`@@ -73,7 +73,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs`
`73`	`73`	`const auto begin = tl.front()->Start();`
`74`	`74`	`const auto drift = GpuDrift( &gpu );`
`75`	`75`	`if( !singleThread ) offset += sstep;`
`76`		`- const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, gpu.thread, yMin, yMax, begin, drift );`
	`76`	`+ const auto partDepth = DispatchGpuZoneLevel( tl, hover, pxns, int64_t( nspx ), wpos, offset, 0, &gpu, yMin, yMax, begin, drift );`
`77`	`77`	`if( partDepth != 0 )`
`78`	`78`	`{`
`79`	`79`	`if( !singleThread )`
`@@ -97,7 +97,7 @@ bool View::DrawGpu( const TimelineContext& ctx, const GpuCtxData& gpu, int& offs`
`97`	`97`	`return depth != 0;`
`98`	`98`	`}`
`99`	`99`
`100`		`-int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& 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 )`
	`100`	`+int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData *ctx, float yMin, float yMax, int64_t begin, int drift )`
`101`	`101`	`{`
`102`	`102`	`const auto ty = ImGui::GetTextLineHeight();`
`103`	`103`	`const auto ostep = ty + 1;`
`@@ -108,28 +108,28 @@ int View::DispatchGpuZoneLevel( const Vector<short_ptr<ZoneEvent>>& vec, bool ho`
`108`	`108`	`{`
`109`	`109`	`if( vec.is_magic() )`
`110`	`110`	`{`
`111`		`- return DrawGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( (Vector<ZoneEvent>)&vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`111`	`+ return DrawGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( (Vector<ZoneEvent>)&vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`112`	`112`	`}`
`113`	`113`	`else`
`114`	`114`	`{`
`115`		`- return DrawGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`115`	`+ return DrawGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`else`
`119`	`119`	`{`
`120`	`120`	`if( vec.is_magic() )`
`121`	`121`	`{`
`122`		`- return SkipGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( (Vector<ZoneEvent>)&vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`122`	`+ return SkipGpuZoneLevel<VectorAdapterDirect<ZoneEvent>>( (Vector<ZoneEvent>)&vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`123`	`123`	`}`
`124`	`124`	`else`
`125`	`125`	`{`
`126`		`- return SkipGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`126`	`+ return SkipGpuZoneLevel<VectorAdapterPointer<ZoneEvent>>( vec, hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`template<typename Adapter, typename V>`
`132`		`-int View::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 )`
	`132`	`+int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift )`
`133`	`133`	`{`
`134`	`134`	`// cast to uint64_t, so that unended zones (end = -1) are still drawn`
`135`	`135`	`auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, m_vd.zvStart ), [begin, drift] ( const auto& l, const auto& r ) { Adapter a; return (uint64_t)AdjustGpuTime( a(l).End(), begin, drift ) < (uint64_t)r; } );`
`@@ -159,6 +159,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`159`	`159`	`const auto start = AdjustGpuTime( ev.GpuStart(), begin, drift );`
`160`	`160`	`end = AdjustGpuTime( end, begin, drift );`
`161`	`161`	`const auto zsz = std::max( ( end - start ) * pxns, pxns * 0.5 );`
	`162`	`+ const auto zoneThread = ctx->thread != 0 ? ctx->thread : m_worker.DecompressThread( ev.Thread() );`
`162`	`163`	`if( zsz < MinVisSize )`
`163`	`164`	`{`
`164`	`165`	`const auto color = GetZoneColor( ev );`
`@@ -202,16 +203,15 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`202`	`203`	`}`
`203`	`204`	`else`
`204`	`205`	`{`
`205`		`- const auto zoneThread = thread != 0 ? thread : m_worker.DecompressThread( ev.Thread() );`
`206`		`- ZoneTooltipGPU( ev );`
	`206`	`+ ZoneTooltipGPU( { &ev.event, ctx } );`
`207`	`207`
`208`	`208`	`if( IsMouseClicked( 2 ) && rend - start > 0 )`
`209`	`209`	`{`
`210`		`- ZoomToZoneGPU( ev );`
	`210`	`+ ZoomToZoneGPU( { &ev.event, ctx } );`
`211`	`211`	`}`
`212`	`212`	`if( IsMouseClicked( 0 ) )`
`213`	`213`	`{`
`214`		`- ShowZoneInfo( ev, zoneThread );`
	`214`	`+ ShowZoneInfo( { &ev.event, ctx }, zoneThread );`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`m_gpuThread = zoneThread;`
`@@ -231,7 +231,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`231`	`231`	`{`
`232`	`232`	`if( ev.Child() >= 0 )`
`233`	`233`	`{`
`234`		`- const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`234`	`+ const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`235`	`235`	`if( d > maxdepth ) maxdepth = d;`
`236`	`236`	`}`
`237`	`237`
`@@ -288,16 +288,15 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`288`	`288`
`289`	`289`	`if( hover && ImGui::IsMouseHoveringRect( wpos + ImVec2( px0, offset ), wpos + ImVec2( px1, offset + tsz.y + 1 ) ) )`
`290`	`290`	`{`
`291`		`- const auto zoneThread = thread != 0 ? thread : m_worker.DecompressThread( ev.thread );`
`292`		`- ZoneTooltipGPU( ev );`
	`291`	`+ ZoneTooltipGPU( { &ev.event, ctx } );`
`293`	`292`
`294`	`293`	`if( !m_zoomAnim.active && IsMouseClicked( 2 ) )`
`295`	`294`	`{`
`296`		`- ZoomToZoneGPU( ev );`
	`295`	`+ ZoomToZoneGPU( { &ev.event, ctx } );`
`297`	`296`	`}`
`298`	`297`	`if( IsMouseClicked( 0 ) )`
`299`	`298`	`{`
`300`		`- ShowZoneInfo( ev, zoneThread );`
	`299`	`+ ShowZoneInfo( { &ev.event, ctx }, zoneThread );`
`301`	`300`	`}`
`302`	`301`
`303`	`302`	`m_gpuThread = zoneThread;`
`@@ -312,7 +311,7 @@ int View::DrawGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`312`	`311`	`}`
`313`	`312`
`314`	`313`	`template<typename Adapter, typename V>`
`315`		`-int View::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 )`
	`314`	`+int View::SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx, const ImVec2& wpos, int _offset, int depth, const GpuCtxData* ctx, float yMin, float yMax, int64_t begin, int drift )`
`316`	`315`	`{`
`317`	`316`	`// cast to uint64_t, so that unended zones (end = -1) are still drawn`
`318`	`317`	`auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, m_vd.zvStart ), [begin, drift] ( const auto& l, const auto& r ) { Adapter a; return (uint64_t)AdjustGpuTime( a(l).End(), begin, drift ) < (uint64_t)r; } );`
`@@ -357,7 +356,7 @@ int View::SkipGpuZoneLevel( const V& vec, bool hover, double pxns, int64_t nspx,`
`357`	`356`	`{`
`358`	`357`	`if( ev.Child() >= 0 )`
`359`	`358`	`{`
`360`		`- const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, thread, yMin, yMax, begin, drift );`
	`359`	`+ const auto d = DispatchGpuZoneLevel( m_worker.GetGpuChildren( ev.Child() ), hover, pxns, nspx, wpos, _offset, depth, ctx, yMin, yMax, begin, drift );`
`361`	`360`	`if( d > maxdepth ) maxdepth = d;`
`362`	`361`	`}`
`363`	`362`	`++it;`
Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,12 @@ void View::ZoomToZone( const ZoneEvent& ev )`
`10`	`10`	`ZoomToRange( ev.Start(), end );`
`11`	`11`	`}`
`12`	`12`
`13`		`-void View::ZoomToZoneGPU( const ZoneEvent& ev )`
	`13`	`+void View::ZoomToZoneGPU( const ZoneEventC evC )`
`14`	`14`	`{`
	`15`	`+ auto& ev = *evC.event;`
	`16`	`+ auto ctx = evC.ctx;`
`15`	`17`	`const auto end = m_worker.GetZoneEndGPU( ev );`
`16`	`18`	`if( end - ev.Start() <= 0 ) return;`
`17`		`- auto ctx = GetZoneCtx( ev );`
`18`	`19`	`if( !ctx )`
`19`	`20`	`{`
`20`	`21`	`ZoomToRange( ev.Start(), end );`
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,7 @@ void View::DrawTimeline()`
`473`	`473`	`}`
`474`	`474`	`if( m_gpuInfoWindow )`
`475`	`475`	`{`
`476`		`- const auto ex = m_worker.GetGpuExtra( *m_gpuInfoWindow );`
	`476`	`+ const auto ex = m_worker.GetGpuExtra( *m_gpuInfoWindow.event );`
`477`	`477`	`const auto px0 = ( ex.CpuStart() - m_vd.zvStart ) * pxns;`
`478`	`478`	`const auto px1 = std::max( px0 + std::max( 1.0, pxns * 0.5 ), ( ex.CpuEnd() - m_vd.zvStart ) * pxns );`
`479`	`479`	`draw->AddRectFilled( ImVec2( wpos.x + px0, linepos.y ), ImVec2( wpos.x + px1, linepos.y + lineh ), 0x2288DD88 );`