Add support for out-of-order monitored fence completion

Author: JeffersonMontgomery-Intel

PresentData/GpuTrace.cpp

@@ -55,7 +55,11 @@ void GpuTrace::PrintRunningContexts() const
 
                 printf(" SequenceId=%u", entry.mSequenceId);
                 if (entry.mPacketTrace == nullptr) {
-                    printf(" WAIT");
+                    if (entry.mCompleted) {
+                        printf(" DONE");
+                    } else {
+                        printf(" WAIT");
+                    }
                 } else {
                     printf(" ProcessId=%u", LookupPacketTraceProcessId(entry.mPacketTrace));
                 }
@@ -295,6 +299,7 @@ void GpuTrace::EnqueueWork(Context* context, uint32_t sequenceId, uint64_t times
     auto entry = &node->mQueue[queueIndex];
     entry->mPacketTrace = packetTrace;
     entry->mSequenceId = sequenceId;
+    entry->mCompleted = false;
     node->mQueueCount += 1;
 
     // If the queue was empty, the packet starts running right away, otherwise
@@ -311,7 +316,6 @@ void GpuTrace::EnqueueWork(Context* context, uint32_t sequenceId, uint64_t times
 
 bool GpuTrace::CompleteWork(Context* context, uint32_t sequenceId, uint64_t timestamp)
 {
-    auto packetTrace = context->mPacketTrace;
     auto node = context->mNode;
 
     // It's possible to miss DmaPacket events during realtime analysis, so try
@@ -329,17 +333,17 @@ bool GpuTrace::CompleteWork(Context* context, uint32_t sequenceId, uint64_t time
     // actual:   [-----]  [-----]  [-----]     [-----]-----]-------]
     //           ^     ^  x     ^  ^     ^        x  ^   ^
     //           s1    i1 s2    i2 s3    i3       s2 i1  s3
-    if (node->mQueueCount == 0) {
+    if (context->mPacketTrace == nullptr || node->mQueueCount == 0) {
         return false;
     }
 
     auto runningSequenceId = node->mQueue[node->mQueueIndex].mSequenceId;
-    if (packetTrace == nullptr || sequenceId < runningSequenceId) {
+    if (sequenceId < runningSequenceId) {
         return false;
     }
 
     // If we get a DmaPacket_Start event with no corresponding DmaPacket_Info,
-    // then sequenceId will be larger than expected.  If this happens, we seach
+    // then sequenceId will be larger than expected.  If this happens, we search
     // through the queue for a match and if no match was found then we ignore
     // this event (we missed both the DmaPacket_Start and DmaPacket_Info for
     // the packet).  In this case, both the missing packet's execution time as
@@ -366,37 +370,54 @@ bool GpuTrace::CompleteWork(Context* context, uint32_t sequenceId, uint64_t time
             }
 
             uint32_t queueIndex = (node->mQueueIndex + missingCount) % (uint32_t) node->mQueue.size();
-            if (node->mQueue[queueIndex].mSequenceId == sequenceId) {
-                // Move current packet into this slot
-                node->mQueue[queueIndex] = node->mQueue[node->mQueueIndex];
+            auto entry = &node->mQueue[queueIndex];
+            if (entry->mSequenceId == sequenceId) {
+
+                // On some 3000-series NVIDIA cards using hardware scheduling, we sometimes get
+                // QueuePacket_Stop events for monitored fence packets out of order (too early).
+                // This is NOT due to missed events, and any previous render packets should still be
+                // considered running/enqueued.  So, we flag these packets as completed so that it
+                // is immediately completed once it reaches the front of the queue.
+                if (entry->mPacketTrace == nullptr) {
+                    entry->mCompleted = true;
+                    return true;
+                }
+
+                // Otherwise, move current packet into this slot
+                *entry = node->mQueue[node->mQueueIndex];
                 node->mQueueIndex = queueIndex;
                 node->mQueueCount -= missingCount;
                 break;
             }
         }
     }
 
-    // Pop the completed packet from the queue.
-    //
     // If this was the process' last executing packet, accumulate the execution
     // duration into the process' count.
-    node->mQueueCount -= 1;
-
-    packetTrace = node->mQueue[node->mQueueIndex].mPacketTrace;
-    if (packetTrace != nullptr) {
-        packetTrace->mRunningPacketCount -= 1;
-        if (packetTrace->mRunningPacketCount == 0) {
-            CompletePacket(packetTrace, timestamp);
+    auto entry = &node->mQueue[node->mQueueIndex];
+    if (entry->mPacketTrace != nullptr) {
+        entry->mPacketTrace->mRunningPacketCount -= 1;
+        if (entry->mPacketTrace->mRunningPacketCount == 0) {
+            CompletePacket(entry->mPacketTrace, timestamp);
         }
     }
 
-    // If there was another queued packet, start it
-    if (node->mQueueCount > 0) {
+    // Pop the completed packet from the queue, and start the next one.
+    for (;;) {
         node->mQueueIndex = (node->mQueueIndex + 1) % (uint32_t) node->mQueue.size();
+        node->mQueueCount -= 1;
+        if (node->mQueueCount == 0) {
+            break;
+        }
+
+        entry = &node->mQueue[node->mQueueIndex];
+        if (entry->mPacketTrace != nullptr) {
+            StartPacket(entry->mPacketTrace, timestamp);
+            break;
+        }
 
-        packetTrace = node->mQueue[node->mQueueIndex].mPacketTrace;
-        if (packetTrace != nullptr) {
-            StartPacket(packetTrace, timestamp);
+        if (!entry->mCompleted) {
+            break;
         }
     }
 

PresentData/GpuTrace.hpp

@@ -28,6 +28,7 @@ class GpuTrace {
         struct EnqueuedPacket {
             PacketTrace* mPacketTrace;      // Frame trace for this packet
             uint32_t mSequenceId;           // Sequence ID for this packet
+            bool mCompleted;                // Flag to signal that the packet completed out-of-order
         };
         std::vector<EnqueuedPacket> mQueue; // Ring buffer of current enqueued packets
         uint32_t mQueueIndex;               // Index into mQueue for currently-running packet