Properly implement per-dispatch synchronization scopes.

Below are the list of all the individual changes, which are a good order
in which to review this CL.

Core changes:
 - Change the tracking in the frontend to produce a synchronization
   scope per dispatch instead of per compute pass. Some bindgroups might
   not be part of any synchronization scopes so we also track all the
   referenced resources on the side so they can be checked during
   Queue::Submit validation.
 - Fix clearing in the GL and Metal backends to use the per-dispatch
   synchronization scopes.
 - Fix the Vulkan backend to use the per dispatch synchronization scopes
   to produce the correct pipeline barriers. This allows the removal of
   previous logic that was subtly incorrect for Indirect buffer. This
   allows the merging of the Compute and Render DescriptorSetTracker into
   a single small helper class.
 - D3D12 changes are similar to Vulkan, but the simplification is just a
   the suppression of a branch with a lot of code in
   BindGroupStateTracker.

Test changes:
 - Fixup all the ResourceUsageTracking tests to follow the WebGPU spec
   for synchronization scopes (fixing a lot of TODOs).
 - Add additional tests checking that Indirect buffers are not allowed
   to be used as a writeable storage in the same synchronization scope.
 - Add tests for Queue::Submit validation correctly taking into account
   resources that are bound but unused in compute passes.
 - Add an end2end test for using a buffer as Indirect and Storage at the
   same time in a DispatchIndirect, which would previously produce
   incorrect barriers in the Vulkan and D3D12 backends.

Other small changes (that I was to lazy to put in a different CL):
 - Add the utils::MakePipelineLayout helper function.
 - Fix Indirect not being in the list of readonly buffer usages (caught
   by a test added in this CL).

Bug: dawn:632
Change-Id: I77263c3535a4ba995faccbf26255da9a2f6ed3b5
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/49887
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Stephen White <senorblanco@chromium.org>

src/dawn_native/ComputePassEncoder.cpp

@@ -20,6 +20,7 @@
 #include "dawn_native/Commands.h"
 #include "dawn_native/ComputePipeline.h"
 #include "dawn_native/Device.h"
+#include "dawn_native/PassResourceUsageTracker.h"
 #include "dawn_native/QuerySet.h"
 
 namespace dawn_native {
@@ -64,6 +65,9 @@ namespace dawn_native {
                 DAWN_TRY(mCommandBufferState.ValidateCanDispatch());
             }
 
+            // Record the synchronization scope for Dispatch, which is just the current bindgroups.
+            AddDispatchSyncScope();
+
             DispatchCmd* dispatch = allocator->Allocate<DispatchCmd>(Command::Dispatch);
             dispatch->x = x;
             dispatch->y = y;
@@ -101,13 +105,18 @@ namespace dawn_native {
                 }
             }
 
+            // Record the synchronization scope for Dispatch, both the bindgroups and the indirect
+            // buffer.
+            SyncScopeUsageTracker scope;
+            scope.BufferUsedAs(indirectBuffer, wgpu::BufferUsage::Indirect);
+            mUsageTracker.AddReferencedBuffer(indirectBuffer);
+            AddDispatchSyncScope(std::move(scope));
+
             DispatchIndirectCmd* dispatch =
                 allocator->Allocate<DispatchIndirectCmd>(Command::DispatchIndirect);
             dispatch->indirectBuffer = indirectBuffer;
             dispatch->indirectOffset = indirectOffset;
 
-            mUsageTracker.BufferUsedAs(indirectBuffer, wgpu::BufferUsage::Indirect);
-
             return {};
         });
     }
@@ -140,13 +149,11 @@ namespace dawn_native {
                     ValidateSetBindGroup(groupIndex, group, dynamicOffsetCount, dynamicOffsets));
             }
 
+            mUsageTracker.AddResourcesReferencedByBindGroup(group);
+
             RecordSetBindGroup(allocator, groupIndex, group, dynamicOffsetCount, dynamicOffsets);
             mCommandBufferState.SetBindGroup(groupIndex, group);
 
-            // TODO(dawn:632): This doesn't match the WebGPU specification. Instead the
-            // synchronization scopes should be created on Dispatch().
-            mUsageTracker.AddBindGroup(group);
-
             return {};
         });
     }
@@ -169,4 +176,12 @@ namespace dawn_native {
         });
     }
 
+    void ComputePassEncoder::AddDispatchSyncScope(SyncScopeUsageTracker scope) {
+        PipelineLayoutBase* layout = mCommandBufferState.GetPipelineLayout();
+        for (BindGroupIndex i : IterateBitSet(layout->GetBindGroupLayoutsMask())) {
+            scope.AddBindGroup(mCommandBufferState.GetBindGroup(i));
+        }
+        mUsageTracker.AddDispatch(scope.AcquireSyncScopeUsage());
+    }
+
 }  // namespace dawn_native