Change SPIRV debugger control flow to emulate maximal reconvergence

Author: Zorro666

renderdoc/driver/shaders/spirv/spirv_debug.cpp

@@ -617,6 +617,9 @@ void ThreadState::JumpToLabel(Id target)
 
   frame->lastBlock = frame->curBlock;
   frame->curBlock = target;
+  enteredBlocks.push_back(frame->curBlock.value());
+
+  diverged = true;
 
   nextInstruction = debugger.GetInstructionForLabel(target) + 1;
 
@@ -734,6 +737,8 @@ void ThreadState::StepNext(ShaderDebugState *state, const rdcarray<ThreadState>
 
   Iter it = debugger.GetIterForInstruction(nextInstruction);
   nextInstruction++;
+  diverged = false;
+  enteredBlocks.clear();
 
   OpDecoder opdata(it);
 

renderdoc/driver/shaders/spirv/spirv_debug.h

@@ -27,6 +27,7 @@
 #include "api/replay/rdcarray.h"
 #include "maths/vec.h"
 #include "spirv_common.h"
+#include "spirv_controlflow.h"
 #include "spirv_processor.h"
 
 struct SPIRVInterfaceAccess;
@@ -231,6 +232,11 @@ struct ThreadState
   // the list of IDs that are currently valid and live
   rdcarray<Id> live;
 
+  // true if executed an operation which could trigger divergence
+  bool diverged;
+  // list of blocks that were entered in a single step (used for tracking thread convergence)
+  rdcarray<uint32_t> enteredBlocks;
+
   std::map<Id, uint32_t> lastWrite;
 
   // quad ID (arbitrary, just used to find neighbours for derivatives)
@@ -528,6 +534,8 @@ class Debugger : public Processor, public ShaderDebugger
     rdcarray<LocalMapping> activeLocalMappings;
   } m_DebugInfo;
 
+  rdcspv::ControlFlow controlFlow;
+
   const ScopeData *GetScope(size_t offset) const;
 };
 

renderdoc/driver/shaders/spirv/spirv_debug_setup.cpp

@@ -1561,6 +1561,7 @@ ShaderDebugTrace *Debugger::BeginDebug(DebugAPIWrapper *api, const ShaderStage s
 
   std::sort(liveGlobals.begin(), liveGlobals.end());
 
+  rdcarray<rdcspv::ThreadIndex> threadIds;
   for(uint32_t i = 0; i < threadsInWorkgroup; i++)
   {
     ThreadState &lane = workgroup[i];
@@ -1589,8 +1590,14 @@ ShaderDebugTrace *Debugger::BeginDebug(DebugAPIWrapper *api, const ShaderStage s
     // now that the globals are allocated and their storage won't move, we can take pointers to them
     for(const PointerId &p : pointerIDs)
       p.Set(*this, global, lane);
+
+    // Only add active lanes to control flow
+    if(!lane.dead)
+      threadIds.push_back(i);
   }
 
+  controlFlow.Construct(threadIds);
+
   // find quad neighbours
   {
     rdcarray<uint32_t> processedQuads;
@@ -2454,6 +2461,7 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
   if(steps == 0)
   {
     ShaderDebugState initial;
+    uint32_t startBlock = INVALID_BLOCK_INDEX;
 
     // we should be sitting at the entry point function prologue, step forward into the first block
     // and past any function-local variable declarations
@@ -2466,6 +2474,7 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
         thread.EnterEntryPoint(&initial);
         FillCallstack(thread, initial);
         initial.nextInstruction = thread.nextInstruction;
+        startBlock = thread.callstack.back()->curBlock.value();
       }
       else
       {
@@ -2487,6 +2496,18 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
 
     ret.push_back(std::move(initial));
 
+    // Set the initial block for the threads in the root tangle
+    ThreadBlockStates threadBlockStates;
+    TangleGroup &tangles = controlFlow.GetTangles();
+    RDCASSERTEQUAL(tangles.size(), 1);
+    RDCASSERTNOTEQUAL(startBlock, INVALID_BLOCK_INDEX);
+    for(Tangle &tangle : tangles)
+    {
+      RDCASSERT(tangle.IsAliveActive());
+      for(uint32_t threadIdx = 0; threadIdx < workgroup.size(); ++threadIdx)
+        threadBlockStates[threadIdx].push_back(startBlock);
+    }
+    controlFlow.UpdateState(threadBlockStates);
     steps++;
   }
 
@@ -2505,29 +2526,66 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
     if(active.Finished())
       break;
 
-    // calculate the current mask of which threads are active
-    CalcActiveMask(activeMask);
+    // Execute the threads in each active tangle
+    ThreadBlockStates threadBlockStates;
+    TangleGroup &tangles = controlFlow.GetTangles();
 
-    // step all active members of the workgroup
-    for(size_t lane = 0; lane < workgroup.size(); lane++)
+    for(Tangle &tangle : tangles)
     {
-      ThreadState &thread = workgroup[lane];
+      if(!tangle.IsAliveActive())
+        continue;
+
+      rdcarray<rdcspv::ThreadReference> threadRefs = tangle.GetThreadRefs();
+      // calculate the current active thread mask from the threads in the tangle
+      {
+        // one bool per workgroup thread
+        activeMask.resize(workgroup.size());
 
-      if(activeMask[lane])
+        // start with all threads as inactive
+        for(size_t i = 0; i < workgroup.size(); i++)
+          activeMask[i] = false;
+
+        // activate the threads in the tangle
+        for(const rdcspv::ThreadReference &ref : threadRefs)
+        {
+          uint32_t idx = ref.id;
+          RDCASSERT(idx < workgroup.size(), idx, workgroup.size());
+          RDCASSERT(!workgroup[idx].Finished());
+          activeMask[idx] = true;
+        }
+      }
+
+      BlockIndex newMergeBlock = INVALID_BLOCK_INDEX;
+      uint32_t countActiveThreads = 0;
+      uint32_t countDivergedThreads = 0;
+      uint32_t countMergeBlockThreads = 0;
+
+      // step all active members of the workgroup
+      for(size_t lane = 0; lane < workgroup.size(); lane++)
       {
-        if(thread.nextInstruction >= instructionOffsets.size())
+        if(!activeMask[lane])
+          continue;
+        ++countActiveThreads;
+
+        ThreadState &thread = workgroup[lane];
+        const uint32_t currentPC = thread.nextInstruction;
+        const uint32_t threadId = lane;
+        RDCASSERTEQUAL(thread.callstack.back()->curBlock.value(), tangle.GetBlockIndex());
+        if(currentPC >= instructionOffsets.size())
         {
           if(lane == activeLaneIndex)
             ret.emplace_back();
 
+          tangle.SetThreadDead(threadId);
           continue;
         }
+        Id prevConvergeBlock = thread.mergeBlock;
 
         if(lane == activeLaneIndex)
         {
           ShaderDebugState state;
 
-          size_t instOffs = instructionOffsets[thread.nextInstruction];
+          size_t instOffs = instructionOffsets[currentPC];
 
           // see if we're retiring any IDs at this state
           for(size_t l = 0; l < thread.live.size();)
@@ -2566,7 +2624,7 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
 
           if(m_DebugInfo.valid)
           {
-            size_t endOffs = instructionOffsets[thread.nextInstruction - 1];
+            size_t endOffs = instructionOffsets[currentPC - 1];
 
             // append any inlined functions to the top of the stack
             InlineData *inlined = m_DebugInfo.lineInline[endOffs];
@@ -2614,8 +2672,53 @@ rdcarray<ShaderDebugState> Debugger::ContinueDebug()
         {
           thread.StepNext(NULL, workgroup, activeMask);
         }
+        threadBlockStates[threadId] = thread.enteredBlocks;
+        if(!thread.enteredBlocks.empty())
+        {
+          const uint32_t nextBlock = thread.callstack.back()->curBlock.value();
+          // The last block entered should be the current block
+          RDCASSERTEQUAL(nextBlock, thread.enteredBlocks.back());
+        }
+
+        Id newConvergeBlock = thread.mergeBlock;
+        // the thread executed a merge block
+        if(newConvergeBlock != prevConvergeBlock)
+        {
+          if(newMergeBlock == INVALID_BLOCK_INDEX)
+          {
+            newMergeBlock = newConvergeBlock.value();
+            RDCASSERTNOTEQUAL(newMergeBlock, INVALID_BLOCK_INDEX);
+          }
+          else
+          {
+            // All the threads in the tangle should converge to the same block
+            RDCASSERTEQUAL(newConvergeBlock.value(), newMergeBlock);
+          }
+          ++countMergeBlockThreads;
+        }
+        // JAKE TODO: function exit is a convergence point
+
+        if(thread.Finished())
+          tangle.SetThreadDead(threadId);
+
+        if(thread.diverged)
+          ++countDivergedThreads;
+      }
+      if(countMergeBlockThreads)
+      {
+        // all the active threads should have a merge block if any have a merge block
+        RDCASSERTEQUAL(countMergeBlockThreads, countActiveThreads);
+        tangle.AddMergePoint(newMergeBlock);
+      }
+
+      if(countDivergedThreads)
+      {
+        // all the active threads should have diverged if any diverges
+        RDCASSERTEQUAL(countDivergedThreads, countActiveThreads);
+        tangle.SetDiverged(true);
       }
     }
+    controlFlow.UpdateState(threadBlockStates);
   }
 
   return ret;
@@ -4324,7 +4427,6 @@ void Debugger::RegisterOp(Iter it)
     curFunction = NULL;
   }
 }
-
 };    // namespace rdcspv
 
 #if ENABLED(ENABLE_UNIT_TESTS)