Use cc crate to build instead of CMake

Cargo.toml

@@ -2,42 +2,49 @@
 members = [".", "mnn-bridge", "mnn-sync", "mnn-sys", "tools/bencher"]
 [workspace.package]
 license = "Apache-2.0"
+repository = "https://github.com/aftershootco/mnn-rs"
 
 [package]
 name = "mnn"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 license = { workspace = true }
+repository = { workspace = true }
+documentation = "https://docs.rs/mnn"
+description = "High level MNN to Rust bindings"
 
 [workspace.dependencies]
-mnn = { version = "0.2.0", path = "." }
+mnn = { version = "0.3.0", path = "." }
 error-stack = { version = "0.5" }
 
 [dependencies]
-libc = "0.2"
-mnn-sys = { version = "0.1", path = "mnn-sys", features = [] }
-thiserror = "2.0"
+mnn-sys = { version = "0.2", path = "mnn-sys", default-features = false, features = [
+  "mnn-threadpool",
+  "sparse-compute",
+] }
+thiserror = "2"
 error-stack.workspace = true
-oneshot = "0.1"
 tracing = { version = "0.1.40", optional = true }
 dunce = "1.0.5"
 serde = { version = "1.0", features = ["derive"], optional = true }
 
 [features]
+opencl = ["mnn-sys/opencl"]
+
 metal = ["mnn-sys/metal"]
 coreml = ["mnn-sys/coreml"]
-vulkan = ["mnn-sys/vulkan"]
-opencl = ["mnn-sys/opencl"]
-opengl = ["mnn-sys/opengl"]
+
+vulkan = [] # This is currently unimplemented
+
 crt_static = ["mnn-sys/crt_static"]
-# Disable mnn-threadpool to enable this
-openmp = ["mnn-sys/openmp"]
-mnn-threadpool = ["mnn-sys/mnn-threadpool"]
+
 tracing = ["dep:tracing"]
 profile = ["tracing"]
 serde = ["dep:serde"]
 
-default = ["mnn-threadpool"]
+simd = ["mnn-sys/simd"]
+
+default = ["simd"]
 
 
 [dev-dependencies]

benches/mnn-bench.rs

@@ -5,7 +5,7 @@ mod mnn_realesr_bench_with_ones {
     use mnn::*;
     #[divan::bench]
     pub fn mnn_realesr_benchmark_cpu(bencher: Bencher) {
-        let mut net = Interpreter::from_file("tests/assets/realesr.mnn").unwrap();
+        let net = Interpreter::from_file("tests/assets/realesr.mnn").unwrap();
         let mut config = ScheduleConfig::new();
         config.set_type(ForwardType::CPU);
         let session = net.create_session(config).unwrap();
@@ -19,7 +19,7 @@ mod mnn_realesr_bench_with_ones {
     #[cfg(feature = "opencl")]
     #[divan::bench]
     pub fn mnn_realesr_benchmark_opencl(bencher: Bencher) {
-        let mut net = Interpreter::from_file("tests/assets/realesr.mnn").unwrap();
+        let net = Interpreter::from_file("tests/assets/realesr.mnn").unwrap();
         let mut config = ScheduleConfig::new();
         config.set_type(ForwardType::OpenCL);
         let session = net.create_session(config).unwrap();
@@ -30,4 +30,19 @@ mod mnn_realesr_bench_with_ones {
             net.wait(&session);
         });
     }
+
+    #[cfg(feature = "metal")]
+    #[divan::bench]
+    pub fn mnn_realesr_benchmark_metal(bencher: Bencher) {
+        let net = Interpreter::from_file("tests/assets/realesr.mnn").unwrap();
+        let mut config = ScheduleConfig::new();
+        config.set_type(ForwardType::Metal);
+        let session = net.create_session(config).unwrap();
+        bencher.bench_local(|| {
+            let mut input = net.input(&session, "data").unwrap();
+            input.fill(1f32);
+            net.run_session(&session).unwrap();
+            net.wait(&session);
+        });
+    }
 }

deny.toml

@@ -88,7 +88,7 @@ ignore = [
 # List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.11 short identifier (+ optional exception)].
-allow = ["MIT", "Apache-2.0", "BSD-3-Clause", "ISC", "Unicode-DFS-2016", "Zlib"]
+allow = ["MIT", "Apache-2.0", "BSD-3-Clause", "ISC", "Unicode-3.0"]
 # The confidence threshold for detecting a license from license text.
 # The higher the value, the more closely the license text must be to the
 # canonical license text of a valid SPDX license file.

examples/inspect.rs

@@ -47,9 +47,9 @@ macro_rules! time {
 pub fn main() -> anyhow::Result<()> {
     use clap::Parser;
     let cli = Cli::parse();
-    let mut interpreter = Interpreter::from_file(&cli.model)?;
+    let net = Interpreter::from_file(&cli.model)?;
     if !cli.no_cache {
-        interpreter.set_cache_file(cli.model.with_extension("cache"), 128)?;
+        net.set_cache_file(cli.model.with_extension("cache"), 128)?;
     }
 
     tracing_subscriber::fmt()
@@ -62,22 +62,22 @@ pub fn main() -> anyhow::Result<()> {
 
     let mut config = ScheduleConfig::new();
     config.set_type(cli.forward);
-    let mut session = time!(interpreter.create_session(config)?; "create session");
+    let mut session = time!(net.create_session(config)?; "create session");
     if !cli.no_cache {
-        interpreter.update_cache_file(&mut session)?;
+        net.update_cache_file(&mut session)?;
     }
 
     let mut current = 0;
     println!("--------------------------------Info--------------------------------");
-    let mem = interpreter.memory(&session)?;
-    let flops = interpreter.flops(&session)?;
+    let mem = net.memory(&session)?;
+    let flops = net.flops(&session)?;
     println!("Memory: {:?}MiB", mem);
     println!("Flops : {:?}M", flops);
-    println!("ResizeStatus : {:?}", interpreter.resize_status(&session)?);
+    println!("ResizeStatus : {:?}", net.resize_status(&session)?);
 
     time!(loop {
         println!("--------------------------------Inputs--------------------------------");
-        interpreter.inputs(&session).iter().for_each(|x| {
+        net.inputs(&session).iter().for_each(|x| {
             match cli.input_data_type {
                 DataType::F32 => {
                     let mut tensor = x.tensor::<f32>().expect("No tensor");
@@ -98,9 +98,9 @@ pub fn main() -> anyhow::Result<()> {
         });
 
         println!("Running session");
-        interpreter.run_session(&session)?;
+        net.run_session(&session)?;
         println!("--------------------------------Outputs--------------------------------");
-        let outputs = interpreter.outputs(&session);
+        let outputs = net.outputs(&session);
         outputs.iter().for_each(|x| {
             match cli.output_data_type {
                 DataType::F32 => {

examples/simple.rs

@@ -17,7 +17,7 @@ pub struct Cli {
 pub fn main() -> anyhow::Result<()> {
     use clap::Parser;
     let cli = Cli::parse();
-    let mut interpreter = Interpreter::from_file(cli.model)?;
+    let net = Interpreter::from_file(cli.model)?;
 
     let mut config = ScheduleConfig::new();
     config.set_type(ForwardType::CPU);
@@ -27,10 +27,10 @@ pub fn main() -> anyhow::Result<()> {
     config.set_backend_config(backend_config);
 
     let now = std::time::Instant::now();
-    let session = interpreter.create_session(config)?;
+    let session = net.create_session(config)?;
     println!("create session time: {:?}", now.elapsed());
-    let mut image = interpreter.input(&session, "image")?;
-    let mut mask = interpreter.input(&session, "mask")?;
+    let mut image = net.input(&session, "image")?;
+    let mut mask = net.input(&session, "mask")?;
     let mut image_tensor = image.create_host_tensor_from_device(false);
     image_tensor.host_mut().fill(1.0f32);
     image.copy_from_host_tensor(&image_tensor)?;
@@ -40,11 +40,11 @@ pub fn main() -> anyhow::Result<()> {
     mask.copy_from_host_tensor(&mask_tensor)?;
     println!("copy time: {:?}", now.elapsed());
 
-    let output = interpreter.output(&session, "output")?;
+    let output = net.output(&session, "output")?;
     // image.copy_from_host_tensor(&unit_tensor)?;
 
     let now = std::time::Instant::now();
-    interpreter.run_session(&session)?;
+    net.run_session(&session)?;
     output.wait(ffi::MapType::MAP_TENSOR_READ, true);
     println!("run time: {:?}", now.elapsed());
 

flake.nix

@@ -111,7 +111,7 @@
             mnn-docs = craneLib.cargoDoc (commonArgs
               // {
                 inherit cargoArtifacts;
-                cargoDocExtraArgs = "-p mnn -p mnn-sys";
+                cargoDocExtraArgs = "-p mnn -p mnn-sys -p mnn-bridge -p mnn-sync";
               });
             mnn-fmt = craneLib.cargoFmt {inherit src;};
             # Audit dependencies
@@ -226,6 +226,7 @@
                     cargo-llvm-cov
                   ]
                 );
+              # ++ (with packages; [bencher inspect]);
             });
         };
       }

mnn-sync/src/lib.rs

@@ -128,7 +128,7 @@ impl SessionRunnerState {
         tracing::trace!("Unloading session");
         match core::mem::take(self) {
             Self::Loaded(sr) => {
-                let net = sr.unload()?;
+                let net = sr.unload();
                 *self = Self::Unloaded(net);
                 Ok(())
             }
@@ -200,23 +200,25 @@ impl SessionState {
 #[derive(Debug)]
 pub struct SessionRunner {
     pub interpreter: Interpreter,
-    pub session: Session,
+    pub session: Session<'static>,
 }
 
-impl SessionRunner {
-    pub fn new(interpreter: Interpreter, session: Session) -> Self {
-        Self {
-            interpreter,
-            session,
-        }
-    }
+// impl Drop for SessionRunner {
+//     fn drop(&mut self) {
+//         drop(self.session);
+//         drop(self.interpreter);
+//     }
+// }
 
-    pub fn create(mut net: Interpreter, config: ScheduleConfig) -> Result<Self> {
+impl SessionRunner {
+    pub fn create(net: Interpreter, config: ScheduleConfig) -> Result<Self> {
         #[cfg(feature = "tracing")]
         tracing::trace!("Creating session");
         #[cfg(feature = "tracing")]
         let now = std::time::Instant::now();
-        let mut session = net.create_session(config)?;
+        let mut session = unsafe {
+            core::mem::transmute::<Session<'_>, Session<'static>>(net.create_session(config)?)
+        };
         net.update_cache_file(&mut session)?;
         #[cfg(feature = "tracing")]
         tracing::trace!("Session created in {:?}", now.elapsed());
@@ -226,20 +228,20 @@ impl SessionRunner {
         })
     }
 
-    pub fn unload(self) -> Result<mnn::Interpreter> {
+    pub fn unload(self) -> mnn::Interpreter {
         let session = self.session;
         let net = self.interpreter;
         drop(session);
-        Ok(net)
+        net
     }
 
     pub fn run_session(&mut self) -> Result<()> {
         self.interpreter.run_session(&self.session)
     }
 
-    pub fn both_mut(&mut self) -> (&mut Interpreter, &mut Session) {
-        (&mut self.interpreter, &mut self.session)
-    }
+    // pub fn both_mut(&mut self) -> (&mut Interpreter, &mut Session) {
+    //     (&mut self.interpreter, &mut self.session)
+    // }
 
     pub fn resize_session(&mut self) -> Result<()> {
         self.interpreter.resize_session(&mut self.session);
@@ -258,7 +260,7 @@ impl SessionRunner {
         &self.session
     }
 
-    pub fn session_mut(&mut self) -> &mut Session {
+    pub fn session_mut(&mut self) -> &mut Session<'static> {
         &mut self.session
     }
 
@@ -504,7 +506,6 @@ pub fn test_sync_api() {
 }
 
 #[test]
-#[ignore = "This test is not reliable on CI"]
 pub fn test_sync_api_race() {
     let interpreter = Interpreter::from_file("../tests/assets/realesr.mnn")
         .expect("Failed to create interpreter");