add support for uint8

Signed-off-by: gterzian <2792687+gterzian@users.noreply.github.com>

Author: gterzian

Cargo.lock

@@ -8,6 +8,7 @@ use std::rc::Rc;
 use dom_struct::dom_struct;
 use js::jsapi::JSObject;
 use js::typedarray::{ArrayBufferU8, Float32, Int8, Int16, Int32, Uint8, Uint16, Uint32};
+use rustnn::graph::DataType;
 use webnn_traits::{ContextId, GraphId, WebNNMsg};
 
 use crate::dom::bindings::buffer_source::create_buffer_source;
@@ -94,6 +95,15 @@ pub(crate) struct MLContext {
     lost: Rc<Promise>,
 }
 
+fn operand_data_type_name(data_type: DataType) -> Option<&'static str> {
+    match data_type {
+        DataType::Float32 => Some("float32"),
+        DataType::Int32 => Some("int32"),
+        DataType::Uint8 => Some("uint8"),
+        _ => None,
+    }
+}
+
 impl MLContext {
     /// <https://webmachinelearning.github.io/webnn/#api-ml-createcontext>
     pub(crate) fn new_inherited(
@@ -1024,7 +1034,11 @@ impl MLContextMethods<crate::DomTypeHolder> for MLContext {
         // - ban very large tensors to avoid exhausting the GPU process
         //   (the "large inputs" tests use ~137 MB per tensor)
 
-        let data_types = Some(vec![MLOperandDataType::Float32, MLOperandDataType::Int32]);
+        let data_types = Some(vec![
+            MLOperandDataType::Float32,
+            MLOperandDataType::Int32,
+            MLOperandDataType::Uint8,
+        ]);
         // limit the size to something comfortably smaller than the large-input
         // tests in wpt (/6000×6000 float32 ≈ 144 000 000 bytes).
         // Pick a value comfortably below the ~144 MB used by the
@@ -1314,11 +1328,8 @@ impl MLContextMethods<crate::DomTypeHolder> for MLContext {
             // Compare descriptor: operand descriptor -> tensor descriptor
             if let Some(op) = gi.operands.get(op_id as usize) {
                 // Compare data type
-                let op_dtype_str = match op.descriptor.data_type {
-                    rustnn::graph::DataType::Float32 => "float32",
-                    rustnn::graph::DataType::Int32 => "int32",
-                    _ => return Err(Error::Type(c"Data type not supported".to_owned())),
-                };
+                let op_dtype_str = operand_data_type_name(op.descriptor.data_type)
+                    .ok_or_else(|| Error::Type(c"Data type not supported".to_owned()))?;
                 if tensor.data_type() != op_dtype_str {
                     return Err(Error::Type(c"input tensor descriptor mismatch".to_owned()));
                 }
@@ -1349,11 +1360,8 @@ impl MLContextMethods<crate::DomTypeHolder> for MLContext {
             };
 
             if let Some(op) = gi.operands.get(op_id as usize) {
-                let op_dtype_str = match op.descriptor.data_type {
-                    rustnn::graph::DataType::Float32 => "float32",
-                    rustnn::graph::DataType::Int32 => "int32",
-                    _ => return Err(Error::Type(c"Data type not supported".to_owned())),
-                };
+                let op_dtype_str = operand_data_type_name(op.descriptor.data_type)
+                    .ok_or_else(|| Error::Type(c"Data type not supported".to_owned()))?;
                 if tensor.data_type() != op_dtype_str {
                     return Err(Error::Type(c"output tensor descriptor mismatch".to_owned()));
                 }

components/script/dom/webnn/mlcontext.rs

@@ -52,6 +52,9 @@ Design notes
 - Implementation note: prefer declaring manager helper types (for example
   `Context`) at module scope rather than inside `run_manager()` so types
   are discoverable, easier to test, and stable for future backend additions.
+- Prefer module-scope helper functions over associated functions when backend
+  helper logic does not use struct state. Keep `impl` blocks focused on
+  behavior that depends on `self` or on type-specific construction.
 - When dispatching graphs we currently only support the macOS CoreML backend.
   Graphs with constant operands must have their bytes recorded (`constant-*`
   operations in `GraphInfo`) before conversion; the manager now auto-populates

components/webnn/README.md

@@ -18,6 +18,17 @@ use rustnn::GraphConverter;
 use rustnn::executors::coreml::{CoremlOutput, prepare_compiled_model_with_weights};
 use rustnn::graph::{ConstantData, DataType, GraphInfo, Operand, get_static_or_max_size};
 
+fn operand_byte_length(operand: &Operand) -> usize {
+    operand
+        .descriptor
+        .shape
+        .iter()
+        .fold(1usize, |acc, d| {
+            acc.saturating_mul(get_static_or_max_size(d) as usize)
+        })
+        .saturating_mul(operand.descriptor.data_type.bytes_per_element())
+}
+
 // helper for converting a CoreML output (or lack thereof) into the byte
 // buffer we store in the manager's tensor store.  Handles all supported
 // data types and falls back to a zeroed buffer when the output is missing.
@@ -54,28 +65,15 @@ fn process_coreml_outputs(operand: &Operand, coreml_out: Option<CoremlOutput>) -
                 }
                 bytes
             },
+            DataType::Uint8 => coreml_out.data.iter().map(|&v| v as u8).collect(),
             _other => {
-                let byte_length = operand
-                    .descriptor
-                    .shape
-                    .iter()
-                    .fold(1usize, |acc, d| {
-                        acc.saturating_mul(get_static_or_max_size(d) as usize)
-                    })
-                    .saturating_mul(4usize);
+                let byte_length = operand_byte_length(operand);
                 vec![0u8; byte_length]
             },
         }
     } else {
         // no CoreML output at all -> zero buffer
-        let byte_length = operand
-            .descriptor
-            .shape
-            .iter()
-            .fold(1usize, |acc, d| {
-                acc.saturating_mul(get_static_or_max_size(d) as usize)
-            })
-            .saturating_mul(4usize);
+        let byte_length = operand_byte_length(operand);
         vec![0u8; byte_length]
     }
 }
@@ -927,6 +925,7 @@ fn try_coreml_execute(
                             iv as f32
                         })
                         .collect(),
+                    DataType::Uint8 => buf.iter().map(|&b| b as f32).collect(),
                     _other => Vec::new(),
                 };