WIP: idk if I need this

Author: ErichDonGubler

deno_webgpu/01_webgpu.js

@@ -22,6 +22,9 @@ import {
   GPUComputePipeline,
   GPUDevice,
   GPUDeviceLostInfo,
+  GPUPipelineError,
+  GPUPipelineErrorInit,
+  GPUPipelineErrorReason,
   GPUPipelineLayout,
   GPUQuerySet,
   GPUQueue,
@@ -56,7 +59,6 @@ import {
   EventTargetPrototype,
   setEventTargetData,
 } from "ext:deno_web/02_event.js";
-import { DOMException } from "ext:deno_web/01_dom_exception.js";
 import { createFilteredInspectProxy } from "ext:deno_console/01_console.js";
 
 const privateCustomInspect = SymbolFor("Deno.privateCustomInspect");
@@ -124,28 +126,7 @@ class GPUInternalError extends GPUError {
 }
 core.registerErrorClass("GPUInternalError", GPUInternalError);
 
-class GPUPipelineError extends DOMException {
-  #reason;
-
-  constructor(message = "", options = { __proto__: null }) {
-    const prefix = "Failed to construct 'GPUPipelineError'";
-    message = webidl.converters.DOMString(message, prefix, "Argument 1");
-    options = webidl.converters.GPUPipelineErrorInit(
-      options,
-      prefix,
-      "Argument 2",
-    );
-    super(message, "GPUPipelineError");
-
-    this.#reason = options.reason;
-  }
-
-  get reason() {
-    webidl.assertBranded(this, GPUPipelineErrorPrototype);
-    return this.#reason;
-  }
-}
-const GPUPipelineErrorPrototype = GPUPipelineError.prototype;
+core.registerErrorClass("GPUPipelineError", GPUPipelineError);
 
 class GPUUncapturedErrorEvent extends Event {
   #error;
@@ -840,25 +821,6 @@ ObjectDefineProperty(GPUQuerySetPrototype, privateCustomInspect, {
 
 // Converters
 
-webidl.converters["GPUPipelineErrorInit"] = webidl.createDictionaryConverter(
-  "GPUPipelineErrorInit",
-  [
-    {
-      key: "reason",
-      converter: webidl.converters.GPUPipelineErrorReason,
-      required: true,
-    },
-  ],
-);
-
-webidl.converters["GPUPipelineErrorReason"] = webidl.createEnumConverter(
-  "GPUPipelineErrorReason",
-  [
-    "validation",
-    "internal",
-  ],
-);
-
 webidl.converters["GPUError"] = webidl.converters.any /* put union here! */;
 
 const dictMembersGPUUncapturedErrorEventInit = [
@@ -918,6 +880,9 @@ export {
   GPUInternalError,
   GPUMapMode,
   GPUOutOfMemoryError,
+  GPUPipelineError,
+  GPUPipelineErrorInit,
+  GPUPipelineErrorReason,
   GPUPipelineLayout,
   GPUQuerySet,
   GPUQueue,

deno_webgpu/device.rs

@@ -6,13 +6,15 @@ use std::num::NonZeroU64;
 use std::rc::Rc;
 
 use deno_core::cppgc::{make_cppgc_object, SameObject};
-use deno_core::op2;
 use deno_core::v8;
 use deno_core::webidl::WebIdlInterfaceConverter;
 use deno_core::GarbageCollected;
+use deno_core::{anyhow, op2};
 use deno_error::JsErrorBox;
 use wgpu_core::binding_model::BindingResource;
-use wgpu_core::pipeline::ProgrammableStageDescriptor;
+use wgpu_core::pipeline::{
+  CreateRenderPipelineError, ProgrammableStageDescriptor,
+};
 use wgpu_types::BindingType;
 
 use super::bind_group::GPUBindGroup;
@@ -29,7 +31,10 @@ 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::{
+  GPUError, GPUGenericError, GPUPipelineError, GPUPipelineErrorInit,
+  GPUPipelineErrorReason,
+};
 use crate::query_set::GPUQuerySet;
 use crate::render_bundle::GPURenderBundleEncoder;
 use crate::render_pipeline::GPURenderPipeline;
@@ -509,7 +514,9 @@ impl GPUDevice {
     &self,
     #[webidl] descriptor: super::render_pipeline::GPURenderPipelineDescriptor,
   ) -> Result<GPURenderPipeline, JsErrorBox> {
-    self.new_render_pipeline(descriptor)
+    let (render_pipeline, err) = self.new_render_pipeline(descriptor)?;
+    self.error_handler.push_error(err);
+    Ok(render_pipeline)
   }
 
   #[async_method]
@@ -529,7 +536,27 @@ impl GPUDevice {
     &self,
     #[webidl] descriptor: super::render_pipeline::GPURenderPipelineDescriptor,
   ) -> Result<GPURenderPipeline, JsErrorBox> {
-    self.new_render_pipeline(descriptor)
+    let (render_pipeline, err) = self.new_render_pipeline(descriptor)?;
+    if let Some(err) = err {
+      use wgpu_types::error::ErrorType;
+      use wgpu_types::error::WebGpuError as _;
+
+      let reason = match err.webgpu_error_type() {
+        ErrorType::Internal => GPUPipelineErrorReason::Internal,
+        ErrorType::Validation => GPUPipelineErrorReason::Validation,
+        ErrorType::OutOfMemory | ErrorType::DeviceLost => {
+          self.error_handler.push_error(Some(err));
+          return Ok(render_pipeline);
+        }
+      };
+      Err(JsErrorBox::from_err(GPUPipelineError::new(
+        GPUPipelineErrorInit { reason },
+        anyhow::Error::new(err),
+      )))
+      // NOTE: `render_pipeline` gets dropped.
+    } else {
+      Ok(render_pipeline)
+    }
   }
 
   fn create_command_encoder<'a>(
@@ -773,7 +800,8 @@ impl GPUDevice {
   fn new_render_pipeline(
     &self,
     descriptor: super::render_pipeline::GPURenderPipelineDescriptor,
-  ) -> Result<GPURenderPipeline, JsErrorBox> {
+  ) -> Result<(GPURenderPipeline, Option<CreateRenderPipelineError>), JsErrorBox>
+  {
     let vertex = wgpu_core::pipeline::VertexState {
       stage: ProgrammableStageDescriptor {
         module: descriptor.vertex.module.id,
@@ -934,14 +962,14 @@ impl GPUDevice {
       None,
     );
 
-    self.error_handler.push_error(err);
-
-    Ok(GPURenderPipeline {
+    let render_pipeline = GPURenderPipeline {
       instance: self.instance.clone(),
       error_handler: self.error_handler.clone(),
       id,
       label: descriptor.label,
-    })
+    };
+
+    Ok((render_pipeline, err))
   }
 }
 

deno_webgpu/error.rs

@@ -5,11 +5,16 @@ use std::fmt::Formatter;
 use std::sync::Mutex;
 use std::sync::OnceLock;
 
+use deno_core::anyhow;
 use deno_core::cppgc::make_cppgc_object;
 use deno_core::v8;
 
+use deno_core::op2;
+use deno_core::webidl::WebIdlInterfaceConverter;
+use deno_core::GarbageCollected;
 use deno_core::JsRuntime;
 use deno_core::V8TaskSpawner;
+use deno_core::WebIDL;
 use wgpu_core::binding_model::CreateBindGroupError;
 use wgpu_core::binding_model::CreateBindGroupLayoutError;
 use wgpu_core::binding_model::CreatePipelineLayoutError;
@@ -379,3 +384,59 @@ pub enum GPUGenericError {
   #[error("Illegal constructor")]
   InvalidConstructor,
 }
+
+#[derive(Debug, thiserror::Error, deno_error::JsError)]
+#[property("code" = 0)]
+#[property("message" = self.to_string())]
+#[property("name" = self.get_name().to_str().unwrap())]
+// TODO: Could we just return the type directly?
+#[property("reason" = self.reason.as_str().to_string())]
+// TODO: use `DOMException`
+#[class(generic)]
+#[error("{reason:?} error: {}", fmt_err(self.inner.as_ref()))]
+pub struct GPUPipelineError {
+  pub reason: GPUPipelineErrorReason,
+  pub(crate) inner: anyhow::Error,
+}
+
+#[derive(WebIDL)]
+#[webidl(dictionary)]
+pub struct GPUPipelineErrorInit {
+  pub reason: GPUPipelineErrorReason,
+}
+
+#[derive(WebIDL, Clone, Copy, Debug)]
+#[webidl(enum)]
+pub enum GPUPipelineErrorReason {
+  Validation,
+  Internal,
+}
+
+impl GPUPipelineError {
+  pub fn new(options: GPUPipelineErrorInit, inner: anyhow::Error) -> Self {
+    let GPUPipelineErrorInit { reason } = options;
+    Self { inner, reason }
+  }
+}
+
+#[op2]
+impl GPUPipelineError {
+  #[constructor]
+  #[cppgc]
+  fn constructor(
+    #[webidl(default = "")] message: String,
+    #[webidl] options: GPUPipelineErrorInit,
+  ) -> GPUPipelineError {
+    GPUPipelineError::new(options, anyhow::Error::msg(message))
+  }
+}
+
+impl WebIdlInterfaceConverter for GPUPipelineError {
+  const NAME: &'static str = "GPUPipelineError";
+}
+
+impl GarbageCollected for GPUPipelineError {
+  fn get_name(&self) -> &'static std::ffi::CStr {
+    c"GPUPipelineError"
+  }
+}

deno_webgpu/lib.rs

@@ -84,6 +84,7 @@ deno_core::extension!(
     compute_pipeline::GPUComputePipeline,
     device::GPUDevice,
     device::GPUDeviceLostInfo,
+    error::GPUPipelineError,
     pipeline_layout::GPUPipelineLayout,
     query_set::GPUQuerySet,
     queue::GPUQueue,

wgpu-core/src/device/resource.rs

@@ -567,7 +567,7 @@ impl Device {
                     buffer: params_buffer,
                     usage: hal::StateTransition {
                         from: wgt::BufferUses::MAP_WRITE,
-                        to: wgt::BufferUses::COPY_SRC,
+                        to: wgt::BufferUses::COPY_DST,
                     },
                 }]);
             pending_writes.command_encoder.copy_buffer_to_buffer(