wip pr comments

Author: ehsanmok

.gitignore

@@ -1,12 +1,11 @@
 /target
 **/*.rs.bk
 Cargo.lock
-/tvm-sys/Cargo.lock
-/tvm-sys/target
-/tests/callback/target
-/tests/basics/target
+/tvm-sys/target/
+/tvm-sys/src/bindgen.rs
 /tests/basics/add_*
+/tests/callback/target
 /examples/resnet/target
 /examples/resnet/deploy_*
 /examples/resnet/*.png
-/examples/resnet/synset.*
+/examples/resnet/synset.*

.rustfmt.toml

@@ -7,7 +7,6 @@ indent_style = "Block"
 wrap_comments = false
 comment_width = 80
 normalize_comments = false
-license_template_path = ""
 format_strings = false
 format_macro_matchers = false
 format_macro_bodies = true
@@ -41,12 +40,12 @@ blank_lines_upper_bound = 1
 blank_lines_lower_bound = 0
 edition = "2015"
 merge_derives = true
-use_try_shorthand = false
+use_try_shorthand = true
 use_field_init_shorthand = false
 force_explicit_abi = true
 condense_wildcard_suffixes = false
 color = "Auto"
-required_version = "0.99.6"
+required_version = "0.99.5"
 unstable_features = false
 disable_all_formatting = false
 skip_children = false

.travis.yml

@@ -2,4 +2,4 @@ language: rust
 rust:
   - nightly
 matrix:
-  fast_finish: true
+  fast_finish: true

Cargo.toml

@@ -16,15 +16,7 @@ crate-type = ["dylib"]
 
 [dependencies]
 tvm-sys = { version = "0.1.0", path = "tvm-sys" }
-ndarray = { version = "0.12.1", features = ["blas"] }
-blas-src = { version = "0.1.2", default-features = false, features = ["openblas"] }
-openblas-src = { version = "0.5.6", default-features = false, features = ["cblas", "system"] }
+ndarray = { version = "0.12.1" }
 lazy_static = "1.1.0"
 num-traits = "0.2"
 custom_error = "1.3.0"
-
-[profile.release]
-debug = true
-
-[package.metadata.release]
-no-dev-version = true

examples/resnet/Cargo.toml

@@ -9,4 +9,4 @@ build = "build.rs"
 ndarray = "0.12.1"
 tvm-frontend = { path = "../../" }
 image = "0.20.1"
-csv = "1"
+csv = "1"

examples/resnet/src/build_resnet.py

@@ -85,4 +85,4 @@ def test_build(target_dir):
 
 	logger.info("testing the build")
 	test_build(sys.argv[1])
-	logger.info("test was successful")
+	logger.info("test was successful")

examples/resnet/src/main.rs

@@ -38,23 +38,24 @@ fn main() -> Result<(), Box<Error>> {
 
     let arr = Array::from_shape_vec((224, 224, 3), pixels)?;
     let arr: ArrayD<f32> = arr.permuted_axes([2, 0, 1]).into_dyn();
-    let arr = arr.insert_axis(Axis(0));
+    let mut arr = arr.insert_axis(Axis(0));
     // create input tensor from rust's ndarray
-    let input = NDArray::from_rust_ndarray(&arr, TVMContext::cpu(0), TVMType::from("float"))?;
+    let input = NDArray::from_rust_ndarray(&mut arr, TVMContext::cpu(0), TVMType::from("float"))?;
     println!("input size is {:?}", input.shape().unwrap());
     let graph = fs::read_to_string("deploy_graph.json")?;
     // load module
     let lib = Module::load(&Path::new("deploy_lib.so"))?;
     // get the global TVM graph runtime function
     let runtime_create_fn =
         Function::get_function("tvm.graph_runtime.create", true, false).unwrap();
-    // create runtime function from Rust
-    let runtime_create_fn_ret = function::Builder::from(runtime_create_fn)
-        .arg(&graph)
-        .arg(&lib)
-        .arg(&ctx.device_type)
-        .arg(&ctx.device_id)
-        .invoke()?;
+
+    let runtime_create_fn_ret = tvm_call!(
+        runtime_create_fn,
+        &graph,
+        &lib,
+        &ctx.device_type,
+        &ctx.device_id
+    )?;
     // get graph runtime module
     let graph_runtime_module = runtime_create_fn_ret.to_module();
     // get the registered `load_params` from runtime module
@@ -65,20 +66,17 @@ fn main() -> Result<(), Box<Error>> {
     let params: Vec<u8> = fs::read("deploy_param.params")?;
     let barr = TVMByteArray::from(&params);
     // load the parameters
-    function::Builder::from(load_param_fn).arg(&barr).invoke()?;
+    tvm_call!(load_param_fn, &barr)?;
     // get the set_input function
     let set_input_fn = graph_runtime_module
         .get_function("set_input", false)
         .unwrap();
-    // set the input via set_input function
-    function::Builder::from(set_input_fn)
-        .arg("data")
-        .arg(&input)
-        .invoke()?;
+
+    tvm_call!(set_input_fn, "data", &input)?;
     // get `run` function from runtime module
     let run_fn = graph_runtime_module.get_function("run", false).unwrap();
-    // execute the run function
-    function::Builder::from(run_fn).invoke()?;
+    // execute the run function. Note that it has no argument.
+    tvm_call!(run_fn,)?;
     // prepare to get the output
     let mut output_shape = vec![1, 1000];
     let output = empty(
@@ -91,10 +89,7 @@ fn main() -> Result<(), Box<Error>> {
         .get_function("get_output", false)
         .unwrap();
     // execute the get output function
-    function::Builder::from(get_output_fn)
-        .arg(&0)
-        .arg(&output)
-        .invoke()?;
+    tvm_call!(get_output_fn, &0, &output)?;
     // flatten the output as Vec<f32>
     let output = output.to_vec::<f32>()?;
     // find the maximum entry in the output and its index

src/bytearray.rs

@@ -4,8 +4,7 @@
 //! This function can be obtained from a graph runtime module loading the model.
 //! For more detail, please see the example `resnet` in `examples` repository.
 
-use std::ffi::CString;
-use std::mem;
+use std::os::raw::c_char;
 
 use ts;
 
@@ -48,15 +47,11 @@ impl TVMByteArray {
 
 impl<'a> From<&'a Vec<u8>> for TVMByteArray {
     fn from(arg: &Vec<u8>) -> Self {
-        unsafe {
-            let data = CString::from_vec_unchecked(arg.to_vec());
-            let barr = ts::TVMByteArray {
-                data: data.as_ptr(),
-                size: arg.len(),
-            };
-            mem::forget(data);
-            TVMByteArray::new(barr)
-        }
+        let barr = ts::TVMByteArray {
+            data: arg.as_ptr() as *const c_char,
+            size: arg.len(),
+        };
+        TVMByteArray::new(barr)
     }
 }
 

src/context.rs

@@ -20,10 +20,9 @@ use std::fmt::{self, Display, Formatter};
 use std::os::raw::c_void;
 use std::ptr;
 
-use ts;
-
 use function;
 use internal_api;
+use ts;
 use Result;
 
 /// Device type which can be from a supported device name. See the supported devices
@@ -81,16 +80,20 @@ impl From<ts::DLDeviceType> for TVMDeviceType {
 
 impl Display for TVMDeviceType {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            TVMDeviceType(1) => write!(f, "cpu"),
-            TVMDeviceType(2) => write!(f, "gpu"),
-            TVMDeviceType(3) => write!(f, "cpu_pinned"),
-            TVMDeviceType(4) => write!(f, "opencl"),
-            TVMDeviceType(8) => write!(f, "meta"),
-            TVMDeviceType(9) => write!(f, "vpi"),
-            TVMDeviceType(10) => write!(f, "rocm"),
-            TVMDeviceType(_) => write!(f, "rpc"),
-        }
+        write!(
+            f,
+            "{}",
+            match self {
+                TVMDeviceType(1) => "cpu",
+                TVMDeviceType(2) => "gpu",
+                TVMDeviceType(3) => "cpu_pinned",
+                TVMDeviceType(4) => "opencl",
+                TVMDeviceType(8) => "meta",
+                TVMDeviceType(9) => "vpi",
+                TVMDeviceType(10) => "rocm",
+                TVMDeviceType(_) => "rpc",
+            }
+        )
     }
 }
 
@@ -145,11 +148,6 @@ impl TVMContext {
             device_id: device_id,
         }
     }
-
-    /// Gets the currect context.
-    pub fn current_context(&self) -> &Self {
-        self
-    }
 }
 
 macro_rules! impl_ctxs {
@@ -186,12 +184,7 @@ impl TVMContext {
     pub fn exist(&self) -> bool {
         let func = internal_api::get_api("_GetDeviceAttr".to_owned());
         let dt = self.device_type.0 as usize;
-        let ret = function::Builder::from(func)
-            .arg(&dt)
-            .arg(&self.device_id)
-            .arg(&0)
-            .invoke()
-            .unwrap();
+        let ret = tvm_call!(func, &dt, &self.device_id, &0).unwrap();
         ret.to_int() != 0
     }
 
@@ -264,11 +257,11 @@ mod tests {
         let ctx = TVMContext::cpu(0);
         println!("ctx: {}", ctx);
         let default_ctx = TVMContext::new(TVMDeviceType(1), 0);
-        assert_eq!(ctx.current_context().clone(), default_ctx);
+        assert_eq!(ctx.clone(), default_ctx);
         assert_ne!(ctx, TVMContext::gpu(0));
 
         let str_ctx = TVMContext::new(TVMDeviceType::from("gpu"), 0);
-        assert_eq!(str_ctx.current_context().clone(), str_ctx);
+        assert_eq!(str_ctx.clone(), str_ctx);
         assert_ne!(str_ctx, TVMContext::new(TVMDeviceType::from("cpu"), 0));
     }
 
@@ -277,21 +270,4 @@ mod tests {
         let ctx = TVMContext::cpu(0);
         assert!(ctx.sync().is_ok())
     }
-
-    #[test]
-    fn dev_attributes() {
-        let ctx = TVMContext::cpu(0);
-        assert!(ctx.exist());
-        println!("max thread per block: {}", ctx.max_threads_per_block());
-        println!("warp size: {}", ctx.warp_size());
-        println!(
-            "max shared memory per block: {}",
-            ctx.max_shared_memory_per_block()
-        );
-        println!("compute version: {}", ctx.compute_version());
-        println!("device name: {}", ctx.device_name());
-        println!("max clock rate: {}", ctx.max_clock_rate());
-        println!("multi processor count: {}", ctx.multi_processor_count());
-        println!("max thread dimensions: {}", ctx.max_thread_dimensions());
-    }
 }