[deno] Fix error reporting for async pipeline creation

This commit is contained in:
Andy Leiserson committed 2025-12-19 15:12:03 -08:00
1 parent 59dbd6b954
commit b9324e9da9
5 files changed
+137 -39

No files matched your search

+1
View File
@@ -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,*
+9 -8
View File
@@ -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,
);
}
}
+76 -29
View File
@@ -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<v8::Promise> {
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<v8::Promise> {
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<wgpu_core::pipeline::CreateComputePipelineError>,
) {
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<wgpu_core::pipeline::CreateRenderPipelineError>,
) {
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,
)
}
}
+40
View File
@@ -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::<crate::PipelineErrorClass>()
.0
.clone();
let constructor =
v8::Local::<v8::Function>::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()
}
+11 -2
View File
@@ -114,13 +114,21 @@ pub fn op_create_gpu(
scope: &mut v8::HandleScope,
webidl_brand: v8::Local<v8::Value>,
set_event_target_data: v8::Local<v8::Value>,
error_event_class: v8::Local<v8::Value>,
uncaptured_error_event_class: v8::Local<v8::Value>,
pipeline_error_class: v8::Local<v8::Value>,
) -> 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<v8::Value>,
}
struct ErrorEventClass(v8::Global<v8::Value>);
struct PipelineErrorClass(v8::Global<v8::Value>);
pub struct GPU;