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>
22 files changed
tree: c36193a827a1d59ae1d8164e96f7cdaaffaac23e
  1. .vscode/
  2. build_overrides/
  3. docs/
  4. examples/
  5. generator/
  6. infra/
  7. scripts/
  8. src/
  9. third_party/
  10. tools/
  11. .clang-format
  12. .gitattributes
  13. .gitignore
  14. .gn
  15. AUTHORS
  16. BUILD.gn
  17. CMakeLists.txt
  18. codereview.settings
  19. dawn.json
  20. dawn_wire.json
  21. DEPS
  22. DIR_METADATA
  23. LICENSE
  24. OWNERS
  25. PRESUBMIT.py
  26. README.chromium
  27. README.md
README.md

Dawn, a WebGPU implementation

Dawn is an open-source and cross-platform implementation of the work-in-progress WebGPU standard. More precisely it implements webgpu.h that is a one-to-one mapping with the WebGPU IDL. Dawn is meant to be integrated as part of a larger system and is the underlying implementation of WebGPU in Chromium.

Dawn provides several WebGPU building blocks:

  • WebGPU C/C++ headers that applications and other building blocks use.
    • The webgpu.h version that Dawn implements.
    • A C++ wrapper for the webgpu.h.
  • A “native” implementation of WebGPU using platforms' GPU APIs:
    • D3D12 on Windows 10
    • Metal on macOS and iOS
    • Vulkan on Windows, Linux, ChromeOS, Android and Fuchsia
    • OpenGL as best effort where available
  • A client-server implementation of WebGPU for applications that are in a sandbox without access to native drivers

Helpful links:

Documentation table of content

Developer documentation:

User documentation: (TODO, figure out what overlaps with the webgpu.h docs)

Status

(TODO)

License

Apache 2.0 Public License, please see LICENSE.

Disclaimer

This is not an officially supported Google product.