Revive the CTS job

andyleiserson · andyleiserson · commit 4c59919b1fff · 2025-05-19T18:57:58.000-07:00
Includes the following minor functional fixes to deno_webgpu: * Don't throw an error immediately when `create_buffer` is called with invalid usage flags. * Implement `on_submitted_work_done`. * Correct validation of GPUExtent3D element count. * Run without tracing (instead of panic) if the DENO_WEBGPU_TRACE env var is not set. Fixes gfx-rs#6838
diff --git a/.github/workflows/cts.yml b/.github/workflows/cts.yml
@@ -0,0 +1,87 @@
+name: CTS
+
+on:
+  pull_request:
+    types: [labeled, opened, synchronize]
+  workflow_dispatch:
+
+env:
+  CARGO_INCREMENTAL: false
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: full
+  MSRV: "1.84"
+
+jobs:
+  cts:
+    # For pull requests, run only run if we add the "PR: run CTS" label
+    #
+    if: "github.event_name == 'workflow_dispatch' || (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'PR: run CTS'))"
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Windows
+          - name: Windows x86_64
+            os: windows-2022
+            target: x86_64-pc-windows-msvc
+            backends: dx12
+
+          # Linux
+          #- name: Linux x86_64
+          #  os: ubuntu-20.04
+          #  target: x86_64-unknown-linux-gnu
+          #  backends: vulkan # gl
+
+    name: CTS ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: checkout repo
+        uses: actions/checkout@v4
+        with:
+          path: wgpu
+
+      - name: checkout cts
+        run: |
+          git clone https://github.com/gpuweb/cts.git
+          cd cts
+          git checkout $(cat ../wgpu/cts_runner/revision.txt)
+
+      - name: Install Repo MSRV toolchain
+        run: |
+          rustup toolchain install ${{ env.MSRV }} --no-self-update --profile=minimal --target ${{ matrix.target }}
+          rustup override set ${{ env.MSRV }}
+          cargo -V
+
+      - name: caching
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: cts-b # suffix for cache busting
+          workspaces: wgpu
+
+      # We enable line numbers for panics, but that's it
+      - name: disable debug
+        shell: bash
+        run: |
+          mkdir -p wgpu/.cargo
+          echo """[profile.dev]
+          debug = 1" > wgpu/.cargo/config.toml
+
+      - name: build CTS runner
+        run: |
+          cargo build --manifest-path wgpu/cts_runner/Cargo.toml
+
+      - name: run CTS
+        shell: bash
+        run: |
+          cd cts;
+          for backend in ${{ matrix.backends }}; do
+            echo "======= CTS TESTS $backend ======";
+            grep -v '^//' ../wgpu/cts_runner/test.lst | while IFS=$' \t\r\n' read test; do
+              echo "=== Running $test ===";
+              DENO_WEBGPU_BACKEND=$backend cargo run --manifest-path ../wgpu/cts_runner/Cargo.toml --frozen -- ./tools/run_deno --verbose "$test";
+            done
+          done
+          echo;
+          echo "Note: Summary reflects only the last test suite, not the entire run."
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -231,11 +231,11 @@ web-sys = { version = "0.3.77", default-features = false }
 web-time = "1"
 
 # deno dependencies
-deno_console = "0.190.0"
-deno_core = "0.336.0"
-deno_url = "0.190.0"
-deno_web = "0.221.0"
-deno_webidl = "0.190.0"
+deno_console = "0.192.0"
+deno_core = "0.338.0"
+deno_url = "0.192.0"
+deno_web = "0.224.0"
+deno_webidl = "0.192.0"
 deno_webgpu = { version = "0.157.0", path = "./deno_webgpu" }
 deno_unsync = "0.4.2"
 deno_error = "0.5.5"
diff --git a/cts_runner/revision.txt b/cts_runner/revision.txt
@@ -1 +1 @@
-7ea73ba6f44c9f6fedfffc06f14c73ea9f2eaa11
+049916a6191725aad5a5692e5a22df47d45c88fa
diff --git a/cts_runner/src/bootstrap.js b/cts_runner/src/bootstrap.js
@@ -29,6 +29,7 @@ import * as performance from "ext:deno_web/15_performance.js";
 import { loadWebGPU } from "ext:deno_webgpu/00_init.js";
 import * as imageData from "ext:deno_web/16_image_data.js";
 const webgpu = loadWebGPU();
+webgpu.initGPU();
 
 // imports needed to pass module evaluation
 import "ext:deno_url/01_urlpattern.js";
diff --git a/cts_runner/test.lst b/cts_runner/test.lst
@@ -1,10 +1,14 @@
 unittests:*
 webgpu:api,operation,command_buffer,basic:*
 webgpu:api,operation,compute,basic:*
+webgpu:api,operation,device,lost:*
 webgpu:api,operation,rendering,basic:clear:*
 webgpu:api,operation,rendering,basic:fullscreen_quad:*
 //FAIL: webgpu:api,operation,rendering,basic:large_draw:*
-webgpu:api,operation,rendering,blending:*
-webgpu:api,operation,rendering,blending:GPUBlendComponent:*
+webgpu:api,operation,rendering,color_target_state:blending,GPUBlendComponent:*
+webgpu:api,operation,rendering,color_target_state:blending,formats:*
+webgpu:api,operation,rendering,color_target_state:blend_constant,setting:*
 webgpu:api,operation,rendering,depth:*
 webgpu:api,operation,rendering,draw:*
+// https://github.com/gfx-rs/wgpu/issues/7391
+//FAIL: webgpu:api,operation,uncapturederror:*
diff --git a/deno_webgpu/adapter.rs b/deno_webgpu/adapter.rs
@@ -126,7 +126,9 @@ impl GPUAdapter {
         let required_limits =
             serde_json::from_value(serde_json::to_value(descriptor.required_limits)?)?;
 
-        let webgpu_trace = std::env::var_os("DENO_WEBGPU_TRACE").unwrap();
+        let trace = std::env::var_os("DENO_WEBGPU_TRACE")
+            .map(|path| wgpu_types::Trace::Directory(std::path::PathBuf::from(path)))
+            .unwrap_or_default();
 
         let wgpu_descriptor = wgpu_types::DeviceDescriptor {
             label: crate::transform_label(descriptor.label.clone()),
@@ -135,7 +137,7 @@ impl GPUAdapter {
             ),
             required_limits,
             memory_hints: Default::default(),
-            trace: wgpu_types::Trace::Directory(std::path::PathBuf::from(webgpu_trace)),
+            trace,
         };
 
         let (device, queue) =
diff --git a/deno_webgpu/device.rs b/deno_webgpu/device.rs
@@ -119,6 +119,7 @@ impl GPUDevice {
     fn queue(&self, scope: &mut v8::HandleScope) -> v8::Global<v8::Object> {
         self.queue_obj.get(scope, |_| GPUQueue {
             id: self.queue,
+            device: self.id,
             error_handler: self.error_handler.clone(),
             instance: self.instance.clone(),
             label: self.label.clone(),
@@ -134,15 +135,12 @@ impl GPUDevice {
 
     #[required(1)]
     #[cppgc]
-    fn create_buffer(
-        &self,
-        #[webidl] descriptor: super::buffer::GPUBufferDescriptor,
-    ) -> Result<GPUBuffer, JsErrorBox> {
+    fn create_buffer(&self, #[webidl] descriptor: super::buffer::GPUBufferDescriptor) -> GPUBuffer {
         let wgpu_descriptor = wgpu_core::resource::BufferDescriptor {
             label: crate::transform_label(descriptor.label.clone()),
             size: descriptor.size,
             usage: wgpu_types::BufferUsages::from_bits(descriptor.usage)
-                .ok_or_else(|| JsErrorBox::type_error("usage is not valid"))?,
+                .unwrap_or(wgpu_types::BufferUsages::empty()),
             mapped_at_creation: descriptor.mapped_at_creation,
         };
 
@@ -152,7 +150,7 @@ impl GPUDevice {
 
         self.error_handler.push_error(err);
 
-        Ok(GPUBuffer {
+        GPUBuffer {
             instance: self.instance.clone(),
             error_handler: self.error_handler.clone(),
             id,
@@ -171,7 +169,7 @@ impl GPUDevice {
                 None
             }),
             mapped_js_buffers: RefCell::new(vec![]),
-        })
+        }
     }
 
     #[required(1)]
diff --git a/deno_webgpu/queue.rs b/deno_webgpu/queue.rs
@@ -1,6 +1,11 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::time::Duration;
+
 use deno_core::cppgc::Ptr;
+use deno_core::futures::channel::oneshot;
 use deno_core::op2;
 use deno_core::GarbageCollected;
 use deno_core::WebIDL;
@@ -21,6 +26,7 @@ pub struct GPUQueue {
     pub label: String,
 
     pub id: wgpu_core::id::QueueId,
+    pub device: wgpu_core::id::DeviceId,
 }
 
 impl Drop for GPUQueue {
@@ -74,9 +80,41 @@ impl GPUQueue {
 
     #[async_method]
     async fn on_submitted_work_done(&self) -> Result<(), JsErrorBox> {
-        Err(JsErrorBox::generic(
-            "This operation is currently not supported",
-        ))
+        let (sender, receiver) = oneshot::channel::<()>();
+
+        let callback = Box::new(move || {
+            sender.send(()).unwrap();
+        });
+
+        self.instance
+            .queue_on_submitted_work_done(self.id, callback);
+
+        let done = Rc::new(RefCell::new(false));
+        let done_ = done.clone();
+        let device_poll_fut = async move {
+            while !*done.borrow() {
+                {
+                    self.instance
+                        .device_poll(self.device, wgpu_types::PollType::wait())
+                        .unwrap();
+                }
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+            Ok::<(), JsErrorBox>(())
+        };
+
+        let receiver_fut = async move {
+            receiver
+                .await
+                .map_err(|e| JsErrorBox::generic(e.to_string()))?;
+            let mut done = done_.borrow_mut();
+            *done = true;
+            Ok::<(), JsErrorBox>(())
+        };
+
+        tokio::try_join!(device_poll_fut, receiver_fut)?;
+
+        Ok(())
     }
 
     #[required(3)]
diff --git a/deno_webgpu/webidl.rs b/deno_webgpu/webidl.rs
@@ -65,7 +65,7 @@ impl<'a> WebIdlConverter<'a> for GPUExtent3D {
                             enforce_range: true,
                         },
                     )?;
-                    if !(conv.len() > 1 && conv.len() <= 3) {
+                    if conv.is_empty() || conv.len() > 3 {
                         return Err(WebIdlError::other(prefix, context, JsErrorBox::type_error(format!("A sequence of number used as a GPUExtent3D must have between 1 and 3 elements, received {} elements", conv.len()))));
                     }
 

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-7ea73ba6f44c9f6fedfffc06f14c73ea9f2eaa11`
	`1`	`+049916a6191725aad5a5692e5a22df47d45c88fa`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ impl<'a> WebIdlConverter<'a> for GPUExtent3D {`
`65`	`65`	`enforce_range: true,`
`66`	`66`	`},`
`67`	`67`	`)?;`
`68`		`- if !(conv.len() > 1 && conv.len() <= 3) {`
	`68`	`+ if conv.is_empty() \|\| conv.len() > 3 {`
`69`	`69`	`return Err(WebIdlError::other(prefix, context, JsErrorBox::type_error(format!("A sequence of number used as a GPUExtent3D must have between 1 and 3 elements, received {} elements", conv.len()))));`
`70`	`70`	`}`
`71`	`71`