fix: add opengl drift correction for gpu zones

Author: bruno-dasilva

public/tracy/TracyOpenGL.hpp

@@ -34,6 +34,7 @@ class GpuCtxScope
 #include <atomic>
 #include <assert.h>
 #include <stdlib.h>
+#include <chrono>
 
 #include "Tracy.hpp"
 #include "../client/TracyProfiler.hpp"
@@ -106,6 +107,13 @@ class GpuCtx
         GLint bits;
         glGetQueryiv( GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &bits );
 
+        // Seed periodic recalibration (see Recalibrate). Without this the single
+        // anchor above is never refreshed and the GPU/CPU clocks drift apart
+        // (measured ~33 ppm), so GPU zones slide off the CPU timeline over a
+        // session. Advertising GpuContextCalibration tells the server to expect
+        // GpuCalibration events and apply rate correction.
+        m_prevCalibration = GetHostTimeNs();
+
         const float period = 1.f;
         const auto thread = GetThreadHandle();
         TracyLfqPrepare( QueueType::GpuNewContext );
@@ -114,7 +122,7 @@ class GpuCtx
         MemWrite( &item->gpuNewContext.thread, thread );
         MemWrite( &item->gpuNewContext.period, period );
         MemWrite( &item->gpuNewContext.context, m_context );
-        MemWrite( &item->gpuNewContext.flags, GpuContextFlags( 0 ) );
+        MemWrite( &item->gpuNewContext.flags, GpuContextFlags( GpuContextCalibration ) );
         MemWrite( &item->gpuNewContext.type, GpuContextType::OpenGl );
 
 #ifdef TRACY_ON_DEMAND
@@ -143,8 +151,6 @@ class GpuCtx
     {
         ZoneScopedC( Color::Red4 );
 
-        if( m_tail == m_head ) return;
-
 #ifdef TRACY_ON_DEMAND
         if( !GetProfiler().IsConnected() )
         {
@@ -153,6 +159,13 @@ class GpuCtx
         }
 #endif
 
+        // Emit a fresh clock-pair periodically so the server can correct GPU/CPU
+        // drift. Done before the (possibly early-returning) query drain so it
+        // still runs on frames with no completed queries.
+        Recalibrate();
+
+        if( m_tail == m_head ) return;
+
         while( m_tail != m_head )
         {
             GLint available;
@@ -173,6 +186,40 @@ class GpuCtx
     }
 
 private:
+    // Monotonic host nanoseconds, used only for measuring the interval between
+    // calibrations (cpuDelta). Independent of Profiler::GetTime() (raw TSC ticks)
+    // on purpose — matches how the D3D12/Vulkan backends source cpuDelta from a
+    // separate ns clock while reporting cpuTime from Profiler::GetTime().
+    static tracy_force_inline int64_t GetHostTimeNs()
+    {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now().time_since_epoch() ).count();
+    }
+
+    // Re-anchor the GPU<->CPU mapping. OpenGL has no atomic dual-clock read
+    // (unlike Vulkan's vkGetCalibratedTimestampsEXT), so we sample GL_TIMESTAMP
+    // and the host clock back-to-back; the sub-microsecond gap is negligible
+    // against a >=1s recalibration interval. The server uses (gpuTime, cpuDelta)
+    // to derive the clock-rate ratio and continuously correct drift.
+    tracy_force_inline void Recalibrate()
+    {
+        const int64_t hostNow = GetHostTimeNs();
+        const int64_t delta = hostNow - m_prevCalibration;
+        if( delta < 1000ll * 1000 * 1000 ) return; // throttle: ~once per second
+
+        int64_t tgpu;
+        glGetInteger64v( GL_TIMESTAMP, &tgpu );
+        const int64_t refCpu = Profiler::GetTime();
+        m_prevCalibration = hostNow;
+
+        TracyLfqPrepare( QueueType::GpuCalibration );
+        MemWrite( &item->gpuCalibration.gpuTime, tgpu );
+        MemWrite( &item->gpuCalibration.cpuTime, refCpu );
+        MemWrite( &item->gpuCalibration.cpuDelta, delta );
+        MemWrite( &item->gpuCalibration.context, m_context );
+        TracyLfqCommit;
+    }
+
     tracy_force_inline unsigned int NextQueryId()
     {
         const auto id = m_head;
@@ -196,6 +243,8 @@ class GpuCtx
 
     unsigned int m_head;
     unsigned int m_tail;
+
+    int64_t m_prevCalibration; // host-ns timestamp of the last emitted calibration
 };
 
 class GpuCtxScope