[dawn][native] Make a separate entry point for ExecutionQueue for callbacks.

- We have seen lock inversion issues w.r.t the lock in ExecutionQueue
  and the device lock before (see 417802523). In order to avoid this
  as the device-lock is a temporary solution for multithreading, this
  change introduces a separate function that we can use to implement
  new code without running into the lock ordering issue.
- This change also depends on the fact that the device lock is now
  recursively acquireable and makes all implementations (modulo Metal)
  explicitly acquire the device lock for CheckAndUpdateCompletedSerials.
  We may be able to remove some of those locks, as we go forwards hence
  the TODOs.
- This change reverts the change in:
  https://dawn-review.googlesource.com/c/dawn/+/246534 so that we can
  guarantee callback ordering. For context, if we call the callbacks
  like we did before outside of the lock after moving them into a
  temporary vector, two threads updating serials 1 and 2 respectively
  can race and each remove one task, then in the non-critical section,
  serial 2's thread can run first resulting in what appears to be
  out of order callback execution. This design has some restrictions
  documented in the comments, but may be alleviated in the future if
  needed by using a recursive mutex for the waiting tasks in
  ExecutionQueue.

Bug: 412761228, 412761367, 40643114, 42240396
Change-Id: I61b217db066d09f22756c5a242968cffc9c9f19c
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/249099
Commit-Queue: Loko Kung <lokokung@google.com>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
8 files changed
tree: 70f24174fc72a29f075f5db9933f5fa9510dc5ee
  1. .github/
  2. .vscode/
  3. build_overrides/
  4. docs/
  5. generator/
  6. include/
  7. infra/
  8. scripts/
  9. src/
  10. test/
  11. third_party/
  12. tools/
  13. webgpu-cts/
  14. .bazelrc
  15. .clang-format
  16. .clang-format-ignore
  17. .clang-tidy
  18. .git-blame-ignore-revs
  19. .gitattributes
  20. .gitignore
  21. .gitmodules
  22. .gn
  23. .style.yapf
  24. .vpython3
  25. AUTHORS
  26. BUILD.bazel
  27. BUILD.gn
  28. CMakeLists.txt
  29. CMakeSettings.json
  30. CODE_OF_CONDUCT.md
  31. codereview.settings
  32. CONTRIBUTING.md
  33. CPPLINT.cfg
  34. DEPS
  35. DIR_METADATA
  36. go.mod
  37. go.sum
  38. go_presubmit_support.py
  39. LICENSE
  40. OWNERS
  41. PRESUBMIT.py
  42. README.chromium
  43. README.md
  44. WATCHLISTS
  45. WORKSPACE.bazel
README.md

Build Status Matrix Space

Dawn, a WebGPU implementation

Dawn is an open-source and cross-platform implementation of the 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, Metal, Vulkan and OpenGL. See per API support for more details.
  • A client-server implementation of WebGPU for applications that are in a sandbox without access to native drivers
  • Tint is a compiler for the WebGPU Shader Language (WGSL) that can be used in standalone to convert shaders from and to WGSL.

Helpful links:

Documentation table of content

Developer documentation:

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

License

BSD 3-Clause License, please see LICENSE.

Disclaimer

This is not an officially supported Google product.