Use failure in tvm_runtime

Author: nhynes

rust/runtime/Cargo.toml

@@ -15,7 +15,7 @@ sgx = ["nom/alloc"]
 
 [dependencies]
 bounded-spsc-queue = "0.4.0"
-error-chain = { version = "0.12.0", default-features = false }
+failure = "0.1.5"
 itertools = "0.7.8"
 lazy_static = "1.1.0"
 ndarray="0.12.1"

rust/runtime/src/allocator.rs

@@ -3,7 +3,7 @@ use alloc::alloc::{self, Layout};
 #[cfg(not(target_env = "sgx"))]
 use std::alloc::{self, Layout};
 
-use crate::errors::*;
+use failure::Error;
 
 const DEFAULT_ALIGN_BYTES: usize = 4;
 
@@ -15,7 +15,7 @@ pub struct Allocation {
 
 impl Allocation {
     /// Allocates a chunk of memory of `size` bytes with optional alignment.
-    pub fn new(size: usize, align: Option<usize>) -> Result<Self> {
+    pub fn new(size: usize, align: Option<usize>) -> Result<Self, Error> {
         let alignment = align.unwrap_or(DEFAULT_ALIGN_BYTES);
         let layout = Layout::from_size_align(size, alignment)?;
         let ptr = unsafe { alloc::alloc(layout.clone()) };

rust/runtime/src/array.rs

@@ -1,5 +1,6 @@
 use std::{convert::TryFrom, mem, os::raw::c_void, ptr, slice};
 
+use failure::Error;
 use ndarray;
 use tvm_common::{
     array::{DataType, TVMContext},
@@ -9,7 +10,7 @@ use tvm_common::{
     },
 };
 
-use crate::{allocator::Allocation, errors::*};
+use crate::allocator::Allocation;
 
 /// A `Storage` is a container which holds `Tensor` data.
 #[derive(PartialEq)]
@@ -22,7 +23,7 @@ pub enum Storage<'a> {
 }
 
 impl<'a> Storage<'a> {
-    pub fn new(size: usize, align: Option<usize>) -> Result<Storage<'static>> {
+    pub fn new(size: usize, align: Option<usize>) -> Result<Storage<'static>, Error> {
         Ok(Storage::Owned(Allocation::new(size, align)?))
     }
 
@@ -258,7 +259,7 @@ macro_rules! impl_ndarray_try_from_tensor {
     ($type:ty, $dtype:expr) => {
         impl<'a, 't> TryFrom<&'a Tensor<'t>> for ndarray::ArrayD<$type> {
             type Error = Error;
-            fn try_from(tensor: &'a Tensor) -> Result<ndarray::ArrayD<$type>> {
+            fn try_from(tensor: &'a Tensor) -> Result<ndarray::ArrayD<$type>, Error> {
                 ensure!(
                     tensor.dtype == $dtype,
                     "Cannot convert Tensor with dtype {:?} to ndarray",

rust/runtime/src/errors.rs

@@ -1,35 +1,49 @@
-#[cfg(target_env = "sgx")]
-use alloc::alloc;
-#[cfg(not(target_env = "sgx"))]
-use std::alloc;
-use std::num;
-
-use ndarray;
-use serde_json;
-
-error_chain! {
-  errors {
-    GraphFormatError(msg: String) {
-      description("unable to load graph")
-      display("could not load graph json: {}", msg)
-    }
-
-    LoadGraphParamsError(msg: String) {
-      description("unable to load graph params")
-      display("could not load graph params: {}", msg)
-    }
-  }
-  foreign_links {
-    Alloc(alloc::AllocErr);
-    GraphDeserialize(serde_json::Error);
-    ParseInt(num::ParseIntError);
-    ShapeError(ndarray::ShapeError);
-    CommonError(tvm_common::errors::Error);
-  }
+#[derive(Debug, Fail)]
+pub enum GraphFormatError {
+    #[fail(display = "Could not parse graph json")]
+    Parse(#[fail(cause)] failure::Error),
+    #[fail(display = "Could not parse graph params")]
+    Params,
+    #[fail(display = "{} is missing attr: {}", 0, 1)]
+    MissingAttr(String, String),
+    #[fail(display = "Missing field: {}", 0)]
+    MissingField(&'static str),
+    #[fail(display = "Invalid DLType: {}", 0)]
+    InvalidDLType(String),
 }
 
-impl From<alloc::LayoutErr> for Error {
-    fn from(_err: alloc::LayoutErr) -> Error {
-        Error::from_kind(ErrorKind::Msg("Layout error".to_string()))
-    }
-}
+// #[cfg(target_env = "sgx")]
+// use alloc::alloc;
+// #[cfg(not(target_env = "sgx"))]
+// use std::alloc;
+// use std::num;
+//
+// use ndarray;
+// use serde_json;
+
+// error_chain! {
+//   errors {
+//     GraphFormatError(msg: String) {
+//       description("unable to load graph")
+//       display("could not load graph json: {}", msg)
+//     }
+//
+//     LoadGraphParamsError(msg: String) {
+//       description("unable to load graph params")
+//       display("could not load graph params: {}", msg)
+//     }
+//   }
+//   foreign_links {
+//     Alloc(alloc::AllocErr);
+//     GraphDeserialize(serde_json::Error);
+//     ParseInt(num::ParseIntError);
+//     ShapeError(ndarray::ShapeError);
+//     CommonError(tvm_common::errors::Error);
+//   }
+// }
+//
+// impl From<alloc::LayoutErr> for Error {
+//     fn from(_err: alloc::LayoutErr) -> Error {
+//         Error::from_kind(ErrorKind::Msg("Layout error".to_string()))
+//     }
+// }

rust/runtime/src/graph.rs

@@ -1,19 +1,17 @@
 use std::{cmp, collections::HashMap, convert::TryFrom, iter::FromIterator, mem, str};
 
+use failure::Error;
 use nom::{alpha1, digit1, le_i32, le_i64, le_u16, le_u32, le_u64, le_u8, types::CompleteStr};
 use serde;
 use serde_json;
-
-use crate::{
-    errors::{Error, ErrorKind, Result},
-    Module, Storage, Tensor,
-};
 use tvm_common::{
     array::{DataType, TVMContext},
     ffi::{DLDataTypeCode_kDLFloat, DLDataTypeCode_kDLInt, DLDataTypeCode_kDLUInt, DLTensor},
     TVMArgValue,
 };
 
+use crate::{errors::GraphFormatError, Module, Storage, Tensor};
+
 // @see `kTVMNDArrayMagic` in `ndarray.h`
 const _NDARRAY_MAGIC: u64 = 0xDD5E40F096B4A13F;
 // @see `kTVMNDArrayListMagic` in `graph_runtime.h`
@@ -44,28 +42,26 @@ pub struct Entry {
 }
 
 impl Graph {
-    fn entry_index(&self, entry: &Entry) -> Result<usize> {
+    fn entry_index(&self, entry: &Entry) -> Result<usize, GraphFormatError> {
         self.node_row_ptr
             .as_ref()
             .map(|nrp| nrp[entry.id] + entry.index)
-            .ok_or("Missing node_row_ptr.".into())
+            .ok_or_else(|| GraphFormatError::MissingField("node_row_ptr"))
     }
 
     /// Attempt to deserialize a JSON attribute to a type `T`.
-    fn get_attr<T: serde::de::DeserializeOwned>(&self, attr: &str) -> Result<T> {
+    fn get_attr<T: serde::de::DeserializeOwned>(&self, attr: &str) -> Result<T, GraphFormatError> {
         Ok(serde_json::from_value::<T>(
             self.attrs
                 .as_ref()
-                .ok_or(ErrorKind::GraphFormatError(
-                    "Missing graph attrs".to_string(),
-                ))?
+                .ok_or(GraphFormatError::MissingField("attrs"))?
                 .get(attr)
-                .ok_or(ErrorKind::GraphFormatError(format!(
-                    "Missing {} attr",
-                    attr
-                )))?
+                .ok_or_else(|| {
+                    GraphFormatError::MissingAttr("graph".to_string(), attr.to_string())
+                })?
                 .to_owned(),
-        )?)
+        )
+        .map_err(|err| GraphFormatError::Parse(err.into()))?)
     }
 }
 
@@ -84,47 +80,39 @@ struct NodeAttrs {
     flatten_data: bool,
 }
 
+macro_rules! get_node_attr {
+    ($node:expr, $attrs:ident, $attr:literal) => {
+        $attrs
+            .get($attr)
+            .ok_or_else(|| GraphFormatError::MissingAttr($node.to_owned(), $attr.to_owned()))
+    };
+}
+
 impl Node {
-    fn parse_attrs(&self) -> Result<NodeAttrs> {
+    fn parse_attrs(&self) -> Result<NodeAttrs, Error> {
         let attrs = self
             .attrs
             .as_ref()
-            .ok_or(format!("Missing node.attrs for `{}`", self.name))?;
-        let func_name = attrs
-            .get("func_name")
-            .ok_or(format!("Node `{}` is missing attrs.func_name", self.name))?
-            .to_string();
-        let num_outputs = attrs
-            .get("num_outputs")
-            .ok_or(format!("Node `{}` is missing attrs.num_outputs", self.name))?
-            .parse::<usize>()?;
-        let flatten_data = attrs
-            .get("flatten_data")
-            .ok_or(format!(
-                "Node `{}` is missing attrs.flatten_data",
-                self.name
-            ))?
-            .parse::<u8>()?
-            == 1;
+            .ok_or_else(|| GraphFormatError::MissingAttr(self.name.clone(), "attrs".to_owned()))?;
         Ok(NodeAttrs {
-            func_name,
-            num_outputs,
-            flatten_data,
+            func_name: get_node_attr!(self.name, attrs, "func_name")?.to_owned(),
+            num_outputs: get_node_attr!(self.name, attrs, "num_outputs")?.parse::<usize>()?,
+            flatten_data: get_node_attr!(self.name, attrs, "flatten_data")?.parse::<u8>()? == 1,
         })
     }
 }
 
 impl<'a> TryFrom<&'a String> for Graph {
     type Error = Error;
-    fn try_from(graph_json: &String) -> Result<Self> {
+    fn try_from(graph_json: &String) -> Result<Self, self::Error> {
         let graph = serde_json::from_str(graph_json)?;
         Ok(graph)
     }
 }
 
 impl<'a> TryFrom<&'a str> for Graph {
     type Error = Error;
-    fn try_from(graph_json: &'a str) -> Result<Self> {
+    fn try_from(graph_json: &'a str) -> Result<Self, Self::Error> {
         let graph = serde_json::from_str(graph_json)?;
         Ok(graph)
     }
@@ -164,7 +152,7 @@ pub struct GraphExecutor<'m, 't> {
 unsafe impl<'m, 't> Send for GraphExecutor<'m, 't> {}
 
 impl<'m, 't> GraphExecutor<'m, 't> {
-    pub fn new<M: 'm + Module>(graph: Graph, lib: &'m M) -> Result<Self> {
+    pub fn new<M: 'm + Module>(graph: Graph, lib: &'m M) -> Result<Self, Error> {
         let tensors = Self::setup_storages(&graph)?;
         Ok(GraphExecutor {
             op_execs: Self::setup_op_execs(&graph, lib, &tensors)?,
@@ -181,7 +169,7 @@ impl<'m, 't> GraphExecutor<'m, 't> {
     }
 
     /// Allocates `Storages` for each `storage_id` and returns `Tensor`s to hold each output.
-    fn setup_storages<'a>(graph: &'a Graph) -> Result<Vec<Tensor<'t>>> {
+    fn setup_storages<'a>(graph: &'a Graph) -> Result<Vec<Tensor<'t>>, Error> {
         let storage_ids = graph.get_attr::<(String, Vec<usize>)>("storage_id")?.1;
         let shapes = graph.get_attr::<(String, Vec<Vec<i64>>)>("shape")?.1;
         let dtypes = graph
@@ -192,13 +180,10 @@ impl<'m, 't> GraphExecutor<'m, 't> {
                 if let Ok((_, dtype)) = tvm_str_to_type(CompleteStr(dltype)) {
                     Ok(dtype)
                 } else {
-                    Err(ErrorKind::GraphFormatError(
-                        format!("Invalid dltype: {}", dltype).to_string(),
-                    )
-                    .into())
+                    Err(GraphFormatError::InvalidDLType(dltype.to_string()))
                 }
             })
-            .collect::<Result<Vec<DataType>>>()?;
+            .collect::<Result<Vec<DataType>, GraphFormatError>>()?;
 
         let align = dtypes.iter().map(|dtype| dtype.bits() as usize).max();
         let mut storage_num_bytes = vec![0usize; *storage_ids.iter().max().unwrap_or(&1) + 1];
@@ -211,7 +196,7 @@ impl<'m, 't> GraphExecutor<'m, 't> {
         let mut storages: Vec<Storage> = storage_num_bytes
             .into_iter()
             .map(|nbytes| Storage::new(nbytes, align))
-            .collect::<Result<Vec<Storage>>>()?;
+            .collect::<Result<Vec<Storage>, Error>>()?;
 
         let tensors = izip!(storage_ids, shapes, dtypes)
             .map(|(storage_id, shape, dtype)| {
@@ -236,7 +221,7 @@ impl<'m, 't> GraphExecutor<'m, 't> {
         graph: &Graph,
         lib: &'m M,
         tensors: &Vec<Tensor<'t>>,
-    ) -> Result<Vec<Box<Fn() + 'm>>> {
+    ) -> Result<Vec<Box<Fn() + 'm>>, Error> {
         ensure!(graph.node_row_ptr.is_some(), "Missing node_row_ptr.");
         let node_row_ptr = graph.node_row_ptr.as_ref().unwrap();
 
@@ -254,9 +239,10 @@ impl<'m, 't> GraphExecutor<'m, 't> {
                 continue;
             }
 
-            let func = lib
-                .get_function(&attrs.func_name)
-                .ok_or(format!("Missing function {}", attrs.func_name))?;
+            let func = lib.get_function(&attrs.func_name).ok_or(format_err!(
+                "Library is missing function {}",
+                attrs.func_name
+            ))?;
             let arg_indices = node
                 .inputs
                 .iter()
@@ -272,7 +258,7 @@ impl<'m, 't> GraphExecutor<'m, 't> {
                         DLTensor::from(tensor)
                     })
                 })
-                .collect::<Result<Vec<DLTensor>>>()
+                .collect::<Result<Vec<DLTensor>, Error>>()
                 .unwrap();
             let op: Box<Fn()> = box move || {
                 let args = dl_tensors
@@ -436,17 +422,15 @@ named!(
 );
 
 /// Loads a param dict saved using `nnvm.compiler.save_param_dict`.
-pub fn load_param_dict(bytes: &[u8]) -> Result<HashMap<String, Tensor>> {
+pub fn load_param_dict(bytes: &[u8]) -> Result<HashMap<String, Tensor>, GraphFormatError> {
     if let Ok((remaining_bytes, param_dict)) = parse_param_dict(bytes) {
-        if remaining_bytes.len() > 0 {
-            bail!(ErrorKind::LoadGraphParamsError("extra input".to_string()))
-        } else {
+        if remaining_bytes.len() == 0 {
             Ok(param_dict)
+        } else {
+            Err(GraphFormatError::Params)
         }
     } else {
-        bail!(ErrorKind::LoadGraphParamsError(
-            "invalid parameters file".to_string()
-        ))
+        Err(GraphFormatError::Params)
     }
 }
 

rust/runtime/src/lib.rs

@@ -25,7 +25,7 @@ extern crate bounded_spsc_queue;
 #[cfg(target_env = "sgx")]
 extern crate core;
 #[macro_use]
-extern crate error_chain;
+extern crate failure;
 #[macro_use]
 extern crate itertools;
 #[macro_use]