🥮 mooncakes.io
    Sign in

    mizchi/webnn/backend/webnn does not have a README file

    TfliteCpuRunner

    source
    pub struct TfliteCpuRunner {
      runtime : 
    TfliteRuntimeModel
    }

    TfliteCpuRunner::compile

    source
    fn TfliteCpuRunner::compile(bytes : Bytes) -> TfliteCpuRunner raise

    Parse a TFLite FlatBuffer for synchronous CPU execution.

    This runner shares the same TFLite I/O validation and quantization boundary as TfliteRunner, but keeps execution independent of WebNN availability.

    TfliteCpuRunner::inputs

    source

    TfliteCpuRunner::outputs

    source

    TfliteCpuRunner::run

    source

    Run a parsed TFLite model through the CPU backend.

    TfliteCpuRunnerCache

    source
    pub struct TfliteCpuRunnerCache {
      entries : Map[String, TfliteCpuRunner]
      entry_bytes : Map[String, Int]
      last_access : Map[String, Int]
      capacity_ : Int
      byte_capacity_ : Int
      resident_bytes_ : Int
      access_counter : Int
      hits_ : Int
      misses_ : Int
      evictions_ : Int
    }

    TfliteCpuRunnerCache::byte_capacity

    source
    fn TfliteCpuRunnerCache::byte_capacity(self : TfliteCpuRunnerCache) -> Int

    TfliteCpuRunnerCache::capacity

    source
    fn TfliteCpuRunnerCache::capacity(self : TfliteCpuRunnerCache) -> Int

    TfliteCpuRunnerCache::clear

    source

    Release parsed CPU models while retaining lifetime hit/miss/eviction counters.

    TfliteCpuRunnerCache::length

    source
    fn TfliteCpuRunnerCache::length(self : TfliteCpuRunnerCache) -> Int

    TfliteCpuRunnerCache::metrics

    source

    TfliteCpuRunnerCache::new

    source

    Create a CPU runner cache for at most 32 parsed models and 64 MiB of source FlatBuffers. It is intended for WebNNRuntime's CPU fallback path.

    TfliteCpuRunnerCache::new_with_capacity

    source

    Construct a CPU cache with a model-count limit and the default 64 MiB source-FlatBuffer budget.

    TfliteCpuRunnerCache::new_with_limits

    source
    fn TfliteCpuRunnerCache::new_with_limits(capacity : Int, byte_capacity : Int) -> TfliteCpuRunnerCache raise 
    TensorError

    Construct a parsed-CPU-model cache bounded by entry count and source bytes.

    TfliteCpuRunnerCache::resident_bytes

    source
    fn TfliteCpuRunnerCache::resident_bytes(self : TfliteCpuRunnerCache) -> Int

    TfliteCpuRunnerCache::run

    source
    async fn TfliteCpuRunnerCache::run(self : TfliteCpuRunnerCache, bytes : Bytes, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    Parse and run bytes through the CPU cache. The SHA-256 digest is computed for this call; use run_artifact to reuse a digest prepared by the caller.

    TfliteCpuRunnerCache::run_artifact

    source
    fn TfliteCpuRunnerCache::run_artifact(self : TfliteCpuRunnerCache, artifact : TfliteModelArtifact, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput] raise

    Run a pre-hashed artifact through the parsed CPU-model cache.

    TfliteCpuRunnerCacheMetrics

    source
    pub struct TfliteCpuRunnerCacheMetrics {
      hits_ : Int
      misses_ : Int
      evictions_ : Int
      entries_ : Int
      resident_bytes_ : Int
      byte_capacity_ : Int
    }

    TfliteCpuRunnerCacheMetrics::byte_capacity

    source

    TfliteCpuRunnerCacheMetrics::entries

    source

    TfliteCpuRunnerCacheMetrics::evictions

    source

    TfliteCpuRunnerCacheMetrics::hits

    source

    TfliteCpuRunnerCacheMetrics::misses

    source

    TfliteCpuRunnerCacheMetrics::resident_bytes

    source

    TfliteModelArtifact

    source
    pub struct TfliteModelArtifact {
      bytes_ : Bytes
      digest_ : String
    }

    Immutable TFLite bytes with a SHA-256 digest computed once.

    Construct this artifact once when a model is loaded, then pass it to WebNNRuntime::run_prepared_tflite to avoid re-hashing large FlatBuffers on every cache lookup.

    TfliteModelArtifact::byte_length

    source
    fn TfliteModelArtifact::byte_length(self : TfliteModelArtifact) -> Int

    TfliteModelArtifact::digest

    source
    fn TfliteModelArtifact::digest(self : TfliteModelArtifact) -> String

    TfliteModelArtifact::from_bytes

    source
    async fn TfliteModelArtifact::from_bytes(bytes : Bytes) -> TfliteModelArtifact

    TfliteRunner

    source

    TfliteRunner::compile

    source

    Compile an arbitrary TFLite FlatBuffer for one sequential execution slot.

    TfliteRunner::compile_pool

    source
    async fn TfliteRunner::compile_pool(bytes : Bytes, preference : 
    DevicePreference    , execution_pool_size : Int) -> TfliteRunner

    Compile an arbitrary TFLite FlatBuffer with independently prepared slots.

    The returned runner owns its program and must be destroyed by its owner.

    TfliteRunner::destroy

    source
    fn TfliteRunner::destroy(self : TfliteRunner) -> Unit

    TfliteRunner::inputs

    source

    TfliteRunner::outputs

    source

    TfliteRunner::pool_size

    source
    fn TfliteRunner::pool_size(self : TfliteRunner) -> Int

    TfliteRunner::run

    source
    async fn TfliteRunner::run(self : TfliteRunner, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    Run named float32 or raw quantized inputs and return named TFLite outputs.

    TfliteRunnerCache

    source
    pub struct TfliteRunnerCache {
      entries : Map[String, TfliteRunner]
      entry_bytes : Map[String, Int]
      last_access : Map[String, Int]
      capacity_ : Int
      byte_capacity_ : Int
      generation : 
    Ref    [Int]
      resident_bytes_ : Int
      access_counter : Int
      hits_ : Int
      misses_ : Int
      evictions_ : Int
    }

    TfliteRunnerCache::byte_capacity

    source
    fn TfliteRunnerCache::byte_capacity(self : TfliteRunnerCache) -> Int

    TfliteRunnerCache::capacity

    source
    fn TfliteRunnerCache::capacity(self : TfliteRunnerCache) -> Int

    TfliteRunnerCache::clear

    source
    fn TfliteRunnerCache::clear(self : TfliteRunnerCache) -> Int

    Clear all retained WebNN programs and prevent an already compiling runner from being reinserted after this call returns.

    TfliteRunnerCache::length

    source
    fn TfliteRunnerCache::length(self : TfliteRunnerCache) -> Int

    TfliteRunnerCache::metrics

    source

    Return lifetime cache counters. clear() releases programs but retains these counters so callers can observe invalidation and eviction behavior.

    TfliteRunnerCache::new

    source

    Create a cache for at most 32 models and 64 MiB of source FlatBuffers.

    The byte budget is deliberately based on model bytes: WebNN does not expose a portable measurement for compiled resource memory.

    TfliteRunnerCache::new_with_capacity

    source

    Construct a cache with a model-count limit and the default 64 MiB budget.

    TfliteRunnerCache::new_with_limits

    source
    fn TfliteRunnerCache::new_with_limits(capacity : Int, byte_capacity : Int) -> TfliteRunnerCache raise 
    TensorError

    Construct a cache bounded by both entry count and source FlatBuffer bytes.

    A model larger than byte_capacity is compiled and run transiently rather than evicting the entire cache only to exceed its budget.

    TfliteRunnerCache::resident_bytes

    source
    fn TfliteRunnerCache::resident_bytes(self : TfliteRunnerCache) -> Int

    TfliteRunnerCache::run

    source

    Run a model through a cache owned by self.

    The SHA-256 digest covers the original FlatBuffer bytes; device preference and slot count are part of the canonical cache key.

    TfliteRunnerCache::run_artifact

    source

    TfliteRunnerCache::run_artifact_pool

    source
    async fn TfliteRunnerCache::run_artifact_pool(self : TfliteRunnerCache, artifact : TfliteModelArtifact, preference : 
    DevicePreference    , execution_pool_size : Int, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    TfliteRunnerCache::run_artifact_pool_with_compiler

    source
    async fn TfliteRunnerCache::run_artifact_pool_with_compiler(self : TfliteRunnerCache, artifact : TfliteModelArtifact, preference : 
    DevicePreference    , execution_pool_size : Int, input_values : Array[TfliteRunnerInput], compile : () -> 
    Promise    [TfliteRunner]) -> Array[TfliteRunnerOutput]

    Run an artifact with an instrumented compiler while preserving cache ownership and invalidation semantics.

    This advanced entry point is useful for compile tracing or externally scheduled compilation. compile must return a runner for artifact, preference, and execution_pool_size; it is evaluated only on a miss.

    TfliteRunnerCache::run_pool

    source
    async fn TfliteRunnerCache::run_pool(self : TfliteRunnerCache, bytes : Bytes, preference : 
    DevicePreference    , execution_pool_size : Int, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    TfliteRunnerCacheKey

    source
    pub struct TfliteRunnerCacheKey {
      model_digest_ : String
      device_ : 
    DevicePreference
      execution_pool_size_ : Int
    }

    TfliteRunnerCacheKey::canonical

    source
    fn TfliteRunnerCacheKey::canonical(self : TfliteRunnerCacheKey) -> String

    TfliteRunnerCacheKey::new

    source

    TfliteRunnerCacheMetrics

    source
    pub struct TfliteRunnerCacheMetrics {
      hits_ : Int
      misses_ : Int
      evictions_ : Int
      entries_ : Int
      resident_bytes_ : Int
      byte_capacity_ : Int
    }

    TfliteRunnerCacheMetrics::byte_capacity

    source
    fn TfliteRunnerCacheMetrics::byte_capacity(self : TfliteRunnerCacheMetrics) -> Int

    TfliteRunnerCacheMetrics::entries

    source

    TfliteRunnerCacheMetrics::evictions

    source

    TfliteRunnerCacheMetrics::hits

    source

    TfliteRunnerCacheMetrics::misses

    source

    TfliteRunnerCacheMetrics::resident_bytes

    source
    fn TfliteRunnerCacheMetrics::resident_bytes(self : TfliteRunnerCacheMetrics) -> Int

    TfliteRunnerInput

    source
    pub struct TfliteRunnerInput {
      name_ : String
      values_ : TfliteRunnerValues
    }

    TfliteRunnerInput::float32

    source
    fn TfliteRunnerInput::float32(name : String, values : Array[Float]) -> TfliteRunnerInput raise 
    TensorError

    TfliteRunnerInput::name

    source
    fn TfliteRunnerInput::name(self : TfliteRunnerInput) -> String

    TfliteRunnerInput::quantized

    source
    fn TfliteRunnerInput::quantized(name : String, values : Array[Int]) -> TfliteRunnerInput raise 
    TensorError

    TfliteRunnerInput::values

    source

    TfliteRunnerOutput

    source
    pub struct TfliteRunnerOutput {
      name_ : String
      values_ : TfliteRunnerValues
    }

    TfliteRunnerOutput::name

    source
    fn TfliteRunnerOutput::name(self : TfliteRunnerOutput) -> String

    TfliteRunnerOutput::values

    source

    TfliteRunnerValues

    source
    pub enum TfliteRunnerValues {
      Float32(Array[Float])
      Quantized(Array[Int])
    }

    Runtime values accepted by and returned from TfliteRunner.

    The WebNN graph always uses float32 internally. Quantized keeps the caller-facing UINT8/INT8 representation at the TFLite boundary.

    WebNNCapabilities

    source
    pub struct WebNNCapabilities {
      contract_ : WebNNContextContract
      preference_ : 
    DevicePreference
      preferred_input_layout_ : 
    InputLayout
      op_support_limits_available_ : Bool
      tensor_io_available_ : Bool
      supported_operators_ : Array[String]
    }

    WebNNCapabilities::contract

    source

    WebNNCapabilities::op_support_limits_available

    source
    fn WebNNCapabilities::op_support_limits_available(self : WebNNCapabilities) -> Bool

    WebNNCapabilities::preference

    source

    WebNNCapabilities::preferred_input_layout

    source

    WebNNCapabilities::supported_operators

    source
    fn WebNNCapabilities::supported_operators(self : WebNNCapabilities) -> Array[String]

    WebNNCapabilities::tensor_io_available

    source
    fn WebNNCapabilities::tensor_io_available(self : WebNNCapabilities) -> Bool

    WebNNContextContract

    source
    pub enum WebNNContextContract {
      Accelerated
      LegacyDeviceType
    } derive(Eq, 
    Debug    )

    WebNNContextContract::to_string

    source
    fn WebNNContextContract::to_string(self : WebNNContextContract) -> String

    WebNNExecution

    source

    WebNNExecution::destroy

    source
    fn WebNNExecution::destroy(self : WebNNExecution) -> Unit

    WebNNExecution::run

    source
    async fn WebNNExecution::run(self : WebNNExecution, input_values : Array[Float]) -> Array[Float]

    WebNNExecution::run_named

    source
    async fn WebNNExecution::run_named(self : WebNNExecution, input_values : Array[WebNNNamedValues]) -> Array[WebNNNamedValues]

    WebNNGraphBuilder

    source
    pub struct WebNNGraphBuilder {
      context : 
    MLContext
      builder : 
    MLGraphBuilder
      supported_operators_ : Array[String]
    }

    WebNNGraphBuilder::compile_litert_program

    source

    The returned program owns self; callers must not destroy the builder.

    WebNNGraphBuilder::compile_litert_program_pool

    source
    async fn WebNNGraphBuilder::compile_litert_program_pool(self : WebNNGraphBuilder, model : 
    LiteRtModel    , pool_size : Int) -> WebNNProgram

    The returned program owns self; a lowering or output-binding failure destroys it.

    WebNNGraphBuilder::compile_named

    source
    async fn WebNNGraphBuilder::compile_named(self : WebNNGraphBuilder, inputs : Array[WebNNInput], outputs : Array[WebNNOutput]) -> WebNNSession

    WebNNGraphBuilder::compile_program_named

    source
    async fn WebNNGraphBuilder::compile_program_named(self : WebNNGraphBuilder, inputs : Array[WebNNInput], outputs : Array[WebNNOutput]) -> WebNNProgram

    WebNNGraphBuilder::compile_program_pool_named

    source
    async fn WebNNGraphBuilder::compile_program_pool_named(self : WebNNGraphBuilder, inputs : Array[WebNNInput], outputs : Array[WebNNOutput], pool_size : Int) -> WebNNProgram

    On success the returned program owns self.

    WebNNGraphBuilder::compile_program_pool_single

    source
    async fn WebNNGraphBuilder::compile_program_pool_single(self : WebNNGraphBuilder, input : WebNNInput, output_name : String, output : WebNNTensor, pool_size : Int) -> WebNNProgram

    On success the returned program owns self.

    WebNNGraphBuilder::compile_program_single

    source
    async fn WebNNGraphBuilder::compile_program_single(self : WebNNGraphBuilder, input : WebNNInput, output_name : String, output : WebNNTensor) -> WebNNProgram

    returned program owns self; callers must not destroy the builder.

    WebNNGraphBuilder::compile_single

    source
    async fn WebNNGraphBuilder::compile_single(self : WebNNGraphBuilder, input : WebNNInput, output_name : String, output : WebNNTensor) -> WebNNSession

    WebNNGraphBuilder::constant

    source

    WebNNGraphBuilder::destroy

    source
    fn WebNNGraphBuilder::destroy(self : WebNNGraphBuilder) -> Unit

    WebNNGraphBuilder::input

    source

    WebNNGraphBuilder::lower_litert

    source

    WebNNGraphBuilder::materialize_bert_encoder_stack

    source

    WebNNGraphBuilder::materialize_feed_forward

    source

    WebNNGraphBuilder::materialize_self_attention

    source

    WebNNGraphBuilder::materialize_transformer_encoder

    source

    WebNNGraphBuilder::materialize_transformer_encoder_stack

    source

    WebNNGraphBuilder::new

    source

    WebNNGraphBuilder::output

    source

    WebNNGraphBuilder::preferred_input_layout

    source

    WebNNGraphBuilder::supported_operators

    source
    fn WebNNGraphBuilder::supported_operators(self : WebNNGraphBuilder) -> Array[String]

    WebNNInput

    source
    pub struct WebNNInput {
      name_ : String
      tensor_ : WebNNTensor
    }

    WebNNInput::tensor

    source
    fn WebNNInput::tensor(self : WebNNInput) -> WebNNTensor

    WebNNLoweredLiteRtGraph

    source
    pub struct WebNNLoweredLiteRtGraph {
      inputs_ : Array[WebNNInput]
      outputs_ : Array[
    LiteRtLoweredValue    [WebNNTensor]]
    }

    WebNNNamedValues

    source
    pub struct WebNNNamedValues {
      name_ : String
      values_ : Array[Float]
    }

    WebNNNamedValues::name

    source
    fn WebNNNamedValues::name(self : WebNNNamedValues) -> String

    WebNNNamedValues::new

    source

    WebNNNamedValues::values

    source
    fn WebNNNamedValues::values(self : WebNNNamedValues) -> Array[Float]

    WebNNOutput

    source
    pub struct WebNNOutput {
      name_ : String
      tensor_ : WebNNTensor
    }

    WebNNProgram

    source
    pub struct WebNNProgram {
      owner : WebNNGraphBuilder
      executions : Array[WebNNExecution]
      scheduler : WebNNProgramScheduler
    }

    WebNNProgram::destroy

    source
    fn WebNNProgram::destroy(self : WebNNProgram) -> Unit

    WebNNProgram::maximum_concurrency

    source
    fn WebNNProgram::maximum_concurrency(self : WebNNProgram) -> Int

    WebNNProgram::pool_size

    source
    fn WebNNProgram::pool_size(self : WebNNProgram) -> Int

    WebNNProgram::run

    source
    async fn WebNNProgram::run(self : WebNNProgram, input_values : Array[Float]) -> Array[Float]

    WebNNProgram::run_named

    source
    async fn WebNNProgram::run_named(self : WebNNProgram, input_values : Array[WebNNNamedValues]) -> Array[WebNNNamedValues]

    WebNNProgramCache

    source
    pub struct WebNNProgramCache {
      entries : Map[String, WebNNProgram]
      generation : 
    Ref    [Int]
    }

    WebNNProgramCache::clear

    source
    fn WebNNProgramCache::clear(self : WebNNProgramCache) -> Int

    WebNNProgramCache::length

    source
    fn WebNNProgramCache::length(self : WebNNProgramCache) -> Int

    WebNNProgramCache::new

    source

    WebNNProgramCache::run_named_or_compile

    source
    async fn WebNNProgramCache::run_named_or_compile(self : WebNNProgramCache, key : WebNNProgramCacheKey, input_values : Array[WebNNNamedValues], compile : () -> 
    Promise    [WebNNProgram]) -> (Array[WebNNNamedValues], Bool)

    Run a named-I/O program through this cache.

    As with run_or_compile(), this cache owns the compiled program and clear() is the sole public way to release its WebNN resources.

    WebNNProgramCache::run_or_compile

    source
    async fn WebNNProgramCache::run_or_compile(self : WebNNProgramCache, key : WebNNProgramCacheKey, input_values : Array[Float], compile : () -> 
    Promise    [WebNNProgram]) -> (Array[Float], Bool)

    Run a single-input/single-output program through this cache.

    The callback is evaluated only on a cache miss. The program it returns is retained and destroyed by this cache; callers receive only inference data and whether the program was already cached.

    WebNNProgramCacheKey

    source
    pub struct WebNNProgramCacheKey {
      graph_hash_ : String
      device_ : 
    DevicePreference
      input_shapes_ : Array[
    Shape    ]
      execution_pool_size_ : Int
    }

    WebNNProgramCacheKey::canonical

    source
    fn WebNNProgramCacheKey::canonical(self : WebNNProgramCacheKey) -> String

    WebNNProgramCacheKey::new

    source

    WebNNProgramCacheKey::new_with_pool

    source

    WebNNProgramScheduler

    source
    type WebNNProgramScheduler

    WebNNRuntime

    source
    pub struct WebNNRuntime {
      preference_ : 
    DevicePreference
      execution_pool_size_ : Int
      fallback_ : WebNNRuntimeFallback
      tflite_cache : TfliteRunnerCache
      cpu_tflite_cache : TfliteCpuRunnerCache
      cpu_fallbacks_ : Int
    }

    High-level, cache-owning entry point for executing TFLite models with WebNN.

    A runtime fixes the device preference and execution-pool size for its lifetime. It retains compiled programs internally, so users need only call clear() when the runtime is no longer needed.

    WebNNRuntime::cache_byte_capacity

    source
    fn WebNNRuntime::cache_byte_capacity(self : WebNNRuntime) -> Int

    WebNNRuntime::cache_capacity

    source
    fn WebNNRuntime::cache_capacity(self : WebNNRuntime) -> Int

    WebNNRuntime::cache_resident_bytes

    source
    fn WebNNRuntime::cache_resident_bytes(self : WebNNRuntime) -> Int

    WebNNRuntime::cache_size

    source
    fn WebNNRuntime::cache_size(self : WebNNRuntime) -> Int

    WebNNRuntime::clear

    source
    fn WebNNRuntime::clear(self : WebNNRuntime) -> Int

    Clear cached WebNN programs and parsed CPU fallback models. The return value remains the number of WebNN programs removed for compatibility.

    WebNNRuntime::cpu_cache_byte_capacity

    source
    fn WebNNRuntime::cpu_cache_byte_capacity(self : WebNNRuntime) -> Int

    WebNNRuntime::cpu_cache_capacity

    source
    fn WebNNRuntime::cpu_cache_capacity(self : WebNNRuntime) -> Int

    WebNNRuntime::cpu_cache_resident_bytes

    source
    fn WebNNRuntime::cpu_cache_resident_bytes(self : WebNNRuntime) -> Int

    WebNNRuntime::cpu_cache_size

    source
    fn WebNNRuntime::cpu_cache_size(self : WebNNRuntime) -> Int

    WebNNRuntime::execution_pool_size

    source
    fn WebNNRuntime::execution_pool_size(self : WebNNRuntime) -> Int

    WebNNRuntime::fallback

    source

    WebNNRuntime::metrics

    source

    WebNNRuntime::new

    source

    WebNNRuntime::new_with_cache_limits

    source
    fn WebNNRuntime::new_with_cache_limits(preference : 
    DevicePreference    , execution_pool_size : Int, cache_capacity : Int, cache_byte_capacity : Int, cpu_cache_capacity : Int, cpu_cache_byte_capacity : Int, fallback : WebNNRuntimeFallback) -> WebNNRuntime raise 
    TensorError

    Construct a runtime with independent WebNN-program and parsed-CPU-model cache budgets. Both byte limits measure source TFLite FlatBuffer bytes.

    WebNNRuntime::new_with_cpu_fallback

    source
    fn WebNNRuntime::new_with_cpu_fallback(preference : 
    DevicePreference    , execution_pool_size : Int, cache_capacity : Int) -> WebNNRuntime raise 
    TensorError

    Construct a bounded runtime that retries failed WebNN work on the CPU.

    WebNNRuntime::new_with_options

    source
    fn WebNNRuntime::new_with_options(preference : 
    DevicePreference    , execution_pool_size : Int, cache_capacity : Int, fallback : WebNNRuntimeFallback) -> WebNNRuntime raise 
    TensorError

    WebNNRuntime::new_with_pool

    source

    WebNNRuntime::preference

    source

    WebNNRuntime::run_prepared_tflite

    source
    async fn WebNNRuntime::run_prepared_tflite(self : WebNNRuntime, artifact : TfliteModelArtifact, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    Execute a model whose bytes and SHA-256 key were prepared once up front.

    This preserves the TFLite I/O contract of run_tflite while avoiding a repeated digest over the original FlatBuffer on cache hits.

    WebNNRuntime::run_tflite

    source
    async fn WebNNRuntime::run_tflite(self : WebNNRuntime, bytes : Bytes, input_values : Array[TfliteRunnerInput]) -> Array[TfliteRunnerOutput]

    Execute arbitrary TFLite FlatBuffer bytes.

    Models are keyed by their SHA-256 digest, fixed device preference, and fixed execution-pool size. The runtime owns every compiled program.

    WebNNRuntimeFallback

    source
    pub(all) enum WebNNRuntimeFallback {
      Disabled
      Cpu
    }

    WebNNRuntimeMetrics

    source
    pub struct WebNNRuntimeMetrics {
      cache_ : TfliteRunnerCacheMetrics
      cpu_cache_ : TfliteCpuRunnerCacheMetrics
      cpu_fallbacks_ : Int
    }

    WebNNRuntimeMetrics::byte_capacity

    source
    fn WebNNRuntimeMetrics::byte_capacity(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_byte_capacity

    source
    fn WebNNRuntimeMetrics::cpu_cache_byte_capacity(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_entries

    source
    fn WebNNRuntimeMetrics::cpu_cache_entries(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_evictions

    source
    fn WebNNRuntimeMetrics::cpu_cache_evictions(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_hits

    source
    fn WebNNRuntimeMetrics::cpu_cache_hits(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_misses

    source
    fn WebNNRuntimeMetrics::cpu_cache_misses(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_cache_resident_bytes

    source
    fn WebNNRuntimeMetrics::cpu_cache_resident_bytes(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::cpu_fallbacks

    source
    fn WebNNRuntimeMetrics::cpu_fallbacks(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::entries

    source
    fn WebNNRuntimeMetrics::entries(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::evictions

    source
    fn WebNNRuntimeMetrics::evictions(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::hits

    source

    WebNNRuntimeMetrics::misses

    source
    fn WebNNRuntimeMetrics::misses(self : WebNNRuntimeMetrics) -> Int

    WebNNRuntimeMetrics::resident_bytes

    source
    fn WebNNRuntimeMetrics::resident_bytes(self : WebNNRuntimeMetrics) -> Int

    WebNNSession

    source
    pub struct WebNNSession {
      context : 
    MLContext
      graph : 
    MLGraph
      input_specs : Array[WebNNValueSpec]
      output_specs : Array[WebNNValueSpec]
    }

    WebNNSession::prepare

    source
    async fn WebNNSession::prepare(self : WebNNSession) -> WebNNExecution

    WebNNSession::run

    source
    async fn WebNNSession::run(self : WebNNSession, input_values : Array[Float]) -> Array[Float]

    WebNNSession::run_named

    source
    async fn WebNNSession::run_named(self : WebNNSession, input_values : Array[WebNNNamedValues]) -> Array[WebNNNamedValues]

    WebNNTensor

    source
    pub struct WebNNTensor {
      builder : 
    MLGraphBuilder
      operand : 
    MLOperand
      shape_ : 
    Shape
      supported_operators : Array[String]
    }

    WebNNValueSpec

    source
    type WebNNValueSpec

    backend_operators

    source
    fn backend_operators() -> Array[String]

    probe_capabilities

    source

    Probe the browser context contract required by this backend.

    The result reports only capabilities used by the library: the context selection contract, opSupportLimits(), prepared tensor I/O, the preferred input layout, and the operators returned for backend_operators().

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io