wasi-nn: turn it on by default (#2859)

* wasi-nn: turn it on by default

This change makes the wasi-nn Cargo feature a default feature. Previously, a wasi-nn user would have to build a separate Wasmtime binary (e.g. `cargo build --features wasi-nn ...`) to use wasi-nn and the resulting binary would require OpenVINO shared libraries to be present in the environment in order to run (otherwise it would fail immediately with linking errors). With recent changes to the `openvino` crate, the wasi-nn implementation can defer the loading of the OpenVINO shared libraries until runtime (i.e., when the user Wasm program calls `wasi_ephemeral_nn::load`) and display a user-level error if anything goes wrong (e.g., the OpenVINO libraries are not present on the system). This runtime-linking addition allows the wasi-nn feature to be turned on by default and shipped with upcoming releases of Wasmtime. This change should be transparent for users who do not use wasi-nn: the `openvino` crate is small and the newly-available wasi-nn imports only affect programs in which they are used.

For those interested in reviewing the runtime linking approach added to the `openvino` crate, see https://github.com/intel/openvino-rs/pull/19.

* wasi-nn spec path: don't use canonicalize

* Allow dependencies using the ISC license

The ISC license should be [just as permissive](https://choosealicense.com/licenses/isc) as MIT, e.g., with no additional limitations.

* Add a `--wasi-modules` flag

This flag controls which WASI modules are made available to the Wasm program. This initial commit enables `wasi-common` by default (equivalent to `--wasi-modules=all`) and allows `wasi-nn` and `wasi-crypto` to be added in either individually (e.g., `--wasi-modules=wasi-nn`) or as a group (e.g., `--wasi-modules=all-experimental`).

* wasi-crypto: fix unused dependency

Co-authored-by: Pat Hickey <pat@moreproductive.org>

crates/wasi-nn/Cargo.toml

@@ -22,7 +22,7 @@ wasmtime-wasi = { path = "../wasi", version = "0.26.0" }
 wiggle = { path = "../wiggle", version = "0.26.0" }
 
 # These dependencies are necessary for the wasi-nn implementation:
-openvino = "0.1.5"
+openvino = { version = "0.3.1", features = ["runtime-linking"] }
 thiserror = "1.0"
 
 [build-dependencies]

crates/wasi-nn/build.rs

@@ -1,11 +1,9 @@
 //! This build script:
 //!  - has the configuration necessary for the wiggle and witx macros.
-
-use std::path::PathBuf;
-
 fn main() {
     // This is necessary for Wiggle/Witx macros.
-    let wasi_root = PathBuf::from("./spec").canonicalize().unwrap();
+    let cwd = std::env::current_dir().unwrap();
+    let wasi_root = cwd.join("spec");
     println!("cargo:rustc-env=WASI_ROOT={}", wasi_root.display());
 
     // Also automatically rebuild if the Witx files change

crates/wasi-nn/src/ctx.rs

@@ -2,7 +2,7 @@
 //! wasi-nn API.
 use crate::r#impl::UsageError;
 use crate::witx::types::{Graph, GraphExecutionContext};
-use openvino::InferenceError;
+use openvino::{InferenceError, SetupError};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::hash::Hash;
@@ -14,8 +14,10 @@ use wiggle::GuestError;
 pub enum WasiNnError {
     #[error("guest error")]
     GuestError(#[from] GuestError),
-    #[error("openvino error")]
-    OpenvinoError(#[from] InferenceError),
+    #[error("openvino inference error")]
+    OpenvinoInferenceError(#[from] InferenceError),
+    #[error("openvino setup error")]
+    OpenvinoSetupError(#[from] SetupError),
     #[error("usage error")]
     UsageError(#[from] UsageError),
 }
@@ -74,7 +76,7 @@ impl ExecutionContext {
 
 /// Capture the state necessary for calling into `openvino`.
 pub struct Ctx {
-    pub(crate) core: openvino::Core,
+    pub(crate) core: Option<openvino::Core>,
     pub(crate) graphs: Table<Graph, (openvino::CNNNetwork, openvino::ExecutableNetwork)>,
     pub(crate) executions: Table<GraphExecutionContext, ExecutionContext>,
 }
@@ -83,7 +85,7 @@ impl Ctx {
     /// Make a new `WasiNnCtx` with the default settings.
     pub fn new() -> WasiNnResult<Self> {
         Ok(Self {
-            core: openvino::Core::new(None)?,
+            core: Option::default(),
             graphs: Table::default(),
             executions: Table::default(),
         })

crates/wasi-nn/src/impl.rs

@@ -12,6 +12,8 @@ use wiggle::GuestPtr;
 
 #[derive(Debug, Error)]
 pub enum UsageError {
+    #[error("Invalid context; has the load function been called?")]
+    InvalidContext,
     #[error("Only OpenVINO's IR is currently supported, passed encoding: {0:?}")]
     InvalidEncoding(GraphEncoding),
     #[error("OpenVINO expects only two buffers (i.e. [ir, weights]), passed: {0}")]
@@ -34,9 +36,21 @@ impl<'a> WasiEphemeralNn for WasiNnCtx {
         if encoding != GraphEncoding::Openvino {
             return Err(UsageError::InvalidEncoding(encoding).into());
         }
+
         if builders.len() != 2 {
             return Err(UsageError::InvalidNumberOfBuilders(builders.len()).into());
         }
+
+        // Construct the context if none is present; this is done lazily (i.e. upon actually loading
+        // a model) because it may fail to find and load the OpenVINO libraries. The laziness limits
+        // the extent of the error only to wasi-nn users, not all WASI users.
+        if self.ctx.borrow().core.is_none() {
+            self.ctx
+                .borrow_mut()
+                .core
+                .replace(openvino::Core::new(None)?);
+        }
+
         let builders = builders.as_ptr();
         let xml = builders.read()?.as_slice()?;
         let weights = builders.add(1)?.read()?.as_slice()?;
@@ -44,11 +58,15 @@ impl<'a> WasiEphemeralNn for WasiNnCtx {
             .ctx
             .borrow_mut()
             .core
+            .as_mut()
+            .ok_or(UsageError::InvalidContext)?
             .read_network_from_buffer(&xml, &weights)?;
         let executable_graph = self
             .ctx
             .borrow_mut()
             .core
+            .as_mut()
+            .ok_or(UsageError::InvalidContext)?
             .load_network(&graph, map_execution_target_to_string(target))?;
         let id = self
             .ctx
@@ -94,7 +112,7 @@ impl<'a> WasiEphemeralNn for WasiNnCtx {
             .dimensions
             .as_slice()?
             .iter()
-            .map(|d| *d as u64)
+            .map(|d| *d as usize)
             .collect::<Vec<_>>();
         let precision = match tensor.type_ {
             TensorType::F16 => Precision::FP16,

crates/wasi-nn/src/witx.rs

@@ -14,7 +14,8 @@ impl<'a> types::UserErrorConversion for WasiNnCtx {
     fn nn_errno_from_wasi_nn_error(&self, e: WasiNnError) -> Result<NnErrno, wiggle::Trap> {
         eprintln!("Host error: {:?}", e);
         match e {
-            WasiNnError::OpenvinoError(_) => unimplemented!(),
+            WasiNnError::OpenvinoSetupError(_) => unimplemented!(),
+            WasiNnError::OpenvinoInferenceError(_) => unimplemented!(),
             WasiNnError::GuestError(_) => unimplemented!(),
             WasiNnError::UsageError(_) => unimplemented!(),
         }