From b9324e9da95657ddd9eecef43d05bf234e39ef9b Mon Sep 17 00:00:00 2001 From: Andy Leiserson Date: Tue, 9 Dec 2025 16:14:03 -0800 Subject: [PATCH] [deno] Fix error reporting for async pipeline creation --- cts_runner/test.lst | 1 + deno_webgpu/01_webgpu.js | 17 ++++--- deno_webgpu/device.rs | 105 ++++++++++++++++++++++++++++----------- deno_webgpu/error.rs | 40 +++++++++++++++ deno_webgpu/lib.rs | 13 ++++- 5 files changed, 137 insertions(+), 39 deletions(-) diff --git a/cts_runner/test.lst b/cts_runner/test.lst index aacb7776e..62afa3008 100644 --- a/cts_runner/test.lst +++ b/cts_runner/test.lst @@ -135,6 +135,7 @@ webgpu:api,validation,render_pass,render_pass_descriptor:attachments,* webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,* webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,* webgpu:api,validation,render_pass,resolve:resolve_attachment:* +webgpu:api,validation,render_pipeline,depth_stencil_state:stencil_write:* webgpu:api,validation,resource_usages,buffer,in_pass_encoder:* // FAIL: 2 other cases in resource_usages,texture,in_pass_encoder. https://github.com/gfx-rs/wgpu/issues/3126 webgpu:api,validation,resource_usages,texture,in_pass_encoder:scope,* diff --git a/deno_webgpu/01_webgpu.js b/deno_webgpu/01_webgpu.js index 8c5ce5c59..5f09cf3af 100644 --- a/deno_webgpu/01_webgpu.js +++ b/deno_webgpu/01_webgpu.js @@ -841,6 +841,14 @@ ObjectDefineProperty(GPUQuerySetPrototype, privateCustomInspect, { // Converters +webidl.converters["GPUPipelineErrorReason"] = webidl.createEnumConverter( + "GPUPipelineErrorReason", + [ + "validation", + "internal", + ], +); + webidl.converters["GPUPipelineErrorInit"] = webidl.createDictionaryConverter( "GPUPipelineErrorInit", [ @@ -852,14 +860,6 @@ webidl.converters["GPUPipelineErrorInit"] = webidl.createDictionaryConverter( ], ); -webidl.converters["GPUPipelineErrorReason"] = webidl.createEnumConverter( - "GPUPipelineErrorReason", - [ - "validation", - "internal", - ], -); - webidl.converters["GPUError"] = webidl.converters.any /* put union here! */; const dictMembersGPUUncapturedErrorEventInit = [ @@ -892,6 +892,7 @@ function initGPU() { webidl.brand, setEventTargetData, GPUUncapturedErrorEvent, + GPUPipelineError, ); } } diff --git a/deno_webgpu/device.rs b/deno_webgpu/device.rs index 98a0048e2..e84f971e2 100644 --- a/deno_webgpu/device.rs +++ b/deno_webgpu/device.rs @@ -29,7 +29,8 @@ use crate::adapter::GPUAdapterInfo; use crate::adapter::GPUSupportedFeatures; use crate::adapter::GPUSupportedLimits; use crate::command_encoder::GPUCommandEncoder; -use crate::error::{GPUError, GPUGenericError}; +use crate::error::make_pipeline_error; +use crate::error::{GPUError, GPUGenericError, GPUPipelineErrorReason}; use crate::query_set::GPUQuerySet; use crate::render_bundle::GPURenderBundleEncoder; use crate::render_pipeline::GPURenderPipeline; @@ -498,7 +499,9 @@ impl GPUDevice { &self, #[webidl] descriptor: super::compute_pipeline::GPUComputePipelineDescriptor, ) -> GPUComputePipeline { - self.new_compute_pipeline(descriptor) + let (pipeline, err) = self.new_compute_pipeline(descriptor); + self.error_handler.push_error(err); + pipeline } #[required(1)] @@ -507,27 +510,63 @@ impl GPUDevice { &self, #[webidl] descriptor: super::render_pipeline::GPURenderPipelineDescriptor, ) -> GPURenderPipeline { - self.new_render_pipeline(descriptor) + let (pipeline, err) = self.new_render_pipeline(descriptor); + self.error_handler.push_error(err); + pipeline } - #[async_method] + #[async_method(fake)] #[required(1)] #[cppgc] - async fn create_compute_pipeline_async( + #[global] + fn create_compute_pipeline_async( &self, + scope: &mut v8::HandleScope, #[webidl] descriptor: super::compute_pipeline::GPUComputePipelineDescriptor, - ) -> GPUComputePipeline { - self.new_compute_pipeline(descriptor) + ) -> v8::Global { + let resolver = v8::PromiseResolver::new(scope).unwrap(); + let promise = resolver.get_promise(scope); + + let (pipeline, err) = self.new_compute_pipeline(descriptor); + if let Some(err) = err { + let err = make_pipeline_error( + scope, + GPUPipelineErrorReason::Validation, + &err.to_string(), + ); + resolver.reject(scope, err.into()); + } else { + let val = make_cppgc_object(scope, pipeline).into(); + resolver.resolve(scope, val); + } + v8::Global::new(scope, promise) } - #[async_method] + #[async_method(fake)] #[required(1)] #[cppgc] - async fn create_render_pipeline_async( + #[global] + fn create_render_pipeline_async( &self, + scope: &mut v8::HandleScope, #[webidl] descriptor: super::render_pipeline::GPURenderPipelineDescriptor, - ) -> GPURenderPipeline { - self.new_render_pipeline(descriptor) + ) -> v8::Global { + let resolver = v8::PromiseResolver::new(scope).unwrap(); + let promise = resolver.get_promise(scope); + + let (pipeline, err) = self.new_render_pipeline(descriptor); + if let Some(err) = err { + let err = make_pipeline_error( + scope, + GPUPipelineErrorReason::Validation, + &err.to_string(), + ); + resolver.reject(scope, err.into()); + } else { + let val = make_cppgc_object(scope, pipeline).into(); + resolver.resolve(scope, val); + } + v8::Global::new(scope, promise) } fn create_command_encoder<'a>( @@ -739,7 +778,10 @@ impl GPUDevice { fn new_compute_pipeline( &self, descriptor: super::compute_pipeline::GPUComputePipelineDescriptor, - ) -> GPUComputePipeline { + ) -> ( + GPUComputePipeline, + Option, + ) { let wgpu_descriptor = wgpu_core::pipeline::ComputePipelineDescriptor { label: crate::transform_label(descriptor.label.clone()), layout: descriptor.layout.into(), @@ -758,20 +800,24 @@ impl GPUDevice { None, ); - self.error_handler.push_error(err); - - GPUComputePipeline { - instance: self.instance.clone(), - error_handler: self.error_handler.clone(), - id, - label: descriptor.label.clone(), - } + ( + GPUComputePipeline { + instance: self.instance.clone(), + error_handler: self.error_handler.clone(), + id, + label: descriptor.label.clone(), + }, + err, + ) } fn new_render_pipeline( &self, descriptor: super::render_pipeline::GPURenderPipelineDescriptor, - ) -> GPURenderPipeline { + ) -> ( + GPURenderPipeline, + Option, + ) { let vertex = wgpu_core::pipeline::VertexState { stage: ProgrammableStageDescriptor { module: descriptor.vertex.module.id, @@ -922,14 +968,15 @@ impl GPUDevice { None, ); - self.error_handler.push_error(err); - - GPURenderPipeline { - instance: self.instance.clone(), - error_handler: self.error_handler.clone(), - id, - label: descriptor.label, - } + ( + GPURenderPipeline { + instance: self.instance.clone(), + error_handler: self.error_handler.clone(), + id, + label: descriptor.label, + }, + err, + ) } } diff --git a/deno_webgpu/error.rs b/deno_webgpu/error.rs index 57bfd1445..71f525237 100644 --- a/deno_webgpu/error.rs +++ b/deno_webgpu/error.rs @@ -379,3 +379,43 @@ pub enum GPUGenericError { #[error("Illegal constructor")] InvalidConstructor, } + +pub enum GPUPipelineErrorReason { + Validation, + #[expect(dead_code)] + Internal, +} + +impl Display for GPUPipelineErrorReason { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + match self { + Self::Validation => f.write_str("validation"), + Self::Internal => f.write_str("internal"), + } + } +} + +pub(crate) fn make_pipeline_error<'a>( + scope: &mut v8::HandleScope<'a>, + reason: GPUPipelineErrorReason, + message: &str, +) -> v8::Local<'a, v8::Object> { + let state = JsRuntime::op_state_from(scope); + let class = state + .borrow() + .borrow::() + .0 + .clone(); + let constructor = + v8::Local::::try_from(v8::Local::new(scope, class)).unwrap(); + let message_str = v8::String::new(scope, message).unwrap(); + let reason_str = v8::String::new(scope, &reason.to_string()).unwrap(); + + let options = v8::Object::new(scope); + let key = v8::String::new(scope, "reason").unwrap(); + options.set(scope, key.into(), reason_str.into()); + + constructor + .new_instance(scope, &[message_str.into(), options.into()]) + .unwrap() +} diff --git a/deno_webgpu/lib.rs b/deno_webgpu/lib.rs index 8c0f79caf..a9aeb5d16 100644 --- a/deno_webgpu/lib.rs +++ b/deno_webgpu/lib.rs @@ -114,13 +114,21 @@ pub fn op_create_gpu( scope: &mut v8::HandleScope, webidl_brand: v8::Local, set_event_target_data: v8::Local, - error_event_class: v8::Local, + uncaptured_error_event_class: v8::Local, + pipeline_error_class: v8::Local, ) -> GPU { state.put(EventTargetSetup { brand: v8::Global::new(scope, webidl_brand), set_event_target_data: v8::Global::new(scope, set_event_target_data), }); - state.put(ErrorEventClass(v8::Global::new(scope, error_event_class))); + state.put(ErrorEventClass(v8::Global::new( + scope, + uncaptured_error_event_class, + ))); + state.put(PipelineErrorClass(v8::Global::new( + scope, + pipeline_error_class, + ))); GPU } @@ -129,6 +137,7 @@ struct EventTargetSetup { set_event_target_data: v8::Global, } struct ErrorEventClass(v8::Global); +struct PipelineErrorClass(v8::Global); pub struct GPU;