Merge branch 'devel' into af3.4

Author: 9prady9

Cargo.toml

@@ -15,13 +15,12 @@ exclude = [
 ]
 
 [dependencies]
-libc = "0.1.10"
-num  = "0.1.27"
-time = "0.1.32"
+libc = "0.2.11"
+num  = "0.1.32"
 lazy_static = "0.2.1"
 
 [build-dependencies]
-rustc-serialize = "0.3.16"
+rustc-serialize = "0.3.19"
 rustc_version = "0.1.7"
 
 [lib]

README.md

@@ -30,7 +30,7 @@ first.
 3. Make sure you add the path to library files to your path environment variables.
     - On Linux & OSX: do `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$AF_PATH/lib`
     - On Windows: Add `%AF_PATH%\lib` to your PATH environment variable.
-4. Add `arrayfire = "3.3.0"` to the dependencies section of your project's Cargo.toml file.
+4. Add `arrayfire = "3.3.1"` to the dependencies section of your project's Cargo.toml file.
 
 Once step (4) is over, you should be able to use ArrayFire in your Rust project. If you find any bugs, please report them [here](https://github.com/arrayfire/arrayfire-rust/issues).
 

examples/pi.rs

@@ -1,8 +1,7 @@
 #[macro_use(mem_info)]
 extern crate arrayfire as af;
-extern crate time;
 
-use time::PreciseTime;
+use std::time::Instant;
 use af::*;
 
 #[allow(unused_must_use)]
@@ -16,7 +15,7 @@ fn main() {
     let x = &randu::<f32>(dims);
     let y = &randu::<f32>(dims);
 
-    let start = PreciseTime::now();
+    let start = Instant::now();
 
     mem_info!("Before benchmark");
 
@@ -30,9 +29,7 @@ fn main() {
         let pi_val = real*4.0/(samples as f64);
     }
 
-    let end = PreciseTime::now();
-
-    println!("Estimated Pi Value in {} seconds", start.to(end) / 100);
+    println!("Estimated Pi Value in {:?}", start.elapsed());
 
     mem_info!("After benchmark");
 }

src/array.rs

@@ -26,7 +26,7 @@ extern {
 
     fn af_get_elements(out: MutAfArray, arr: AfArray) -> c_int;
 
-    fn af_get_type(out: *mut uint8_t, arr: AfArray) -> c_int;
+    fn af_get_type(out: *mut c_int, arr: AfArray) -> c_int;
 
     fn af_get_dims(dim0: *mut c_longlong, dim1: *mut c_longlong, dim2: *mut c_longlong,
                    dim3: *mut c_longlong, arr: AfArray) -> c_int;
@@ -206,8 +206,8 @@ impl Array {
     /// Returns the Array data type
     pub fn get_type(&self) -> DType {
         unsafe {
-            let mut ret_val: u8 = 0;
-            let err_val = af_get_type(&mut ret_val as *mut uint8_t, self.handle as AfArray);
+            let mut ret_val: i32 = 0;
+            let err_val = af_get_type(&mut ret_val as *mut c_int, self.handle as AfArray);
             HANDLE_ERROR(AfError::from(err_val));
             DType::from(ret_val)
         }

src/defines.rs

@@ -106,6 +106,7 @@ impl Error for AfError {
 }
 
 /// Types of Array data type
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum DType {
     /// 32 bit float
@@ -135,6 +136,7 @@ pub enum DType {
 }
 
 /// Dictates the interpolation method to be used by a function
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum InterpType {
     /// Nearest Neighbor interpolation method
@@ -148,6 +150,7 @@ pub enum InterpType {
 }
 
 /// Helps determine how to pad kernels along borders
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum BorderType {
     /// Pad using zeros
@@ -157,6 +160,7 @@ pub enum BorderType {
 }
 
 /// Used by `regions` function to identify type of connectivity
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Connectivity {
     /// North-East-South-West (N-E-S-W) connectivity from given pixel/point
@@ -166,6 +170,7 @@ pub enum Connectivity {
 }
 
 /// Helps determine the size of output of convolution
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ConvMode {
     /// Default convolution mode where output size is same as input size
@@ -175,6 +180,7 @@ pub enum ConvMode {
 }
 
 /// Helps determine if convolution is in Spatial or Frequency domain
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ConvDomain {
     /// ArrayFire chooses whether the convolution will be in spatial domain or frequency domain
@@ -186,6 +192,7 @@ pub enum ConvDomain {
 }
 
 /// Error metric used by `matchTemplate` function
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum MatchType {
     /// Sum of Absolute Differences
@@ -209,6 +216,7 @@ pub enum MatchType {
 }
 
 /// Identify the color space of given image(Array)
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ColorSpace {
     /// Grayscale color space
@@ -220,6 +228,7 @@ pub enum ColorSpace {
 }
 
 /// Helps determine the type of a Matrix
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum MatProp {
     /// Default (no-op)
@@ -248,6 +257,7 @@ pub enum MatProp {
 
 /// Norm type
 #[allow(non_camel_case_types)]
+#[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum NormType {
     /// Treats input as a vector and return sum of absolute values

src/device/mod.rs

@@ -131,12 +131,12 @@ pub fn get_device() -> i32 {
 /// * Number of buffers allocated
 /// * Number of bytes locked
 /// * Number of buffers locked
-pub fn device_mem_info() -> (u64, u64, u64, u64) {
+pub fn device_mem_info() -> (usize, usize, usize, usize) {
     unsafe {
-        let mut o0: u64 = 0;
-        let mut o1: u64 = 0;
-        let mut o2: u64 = 0;
-        let mut o3: u64 = 0;
+        let mut o0: usize = 0;
+        let mut o1: usize = 0;
+        let mut o2: usize = 0;
+        let mut o3: usize = 0;
         let err_val = af_device_mem_info(&mut o0 as *mut size_t,
                                          &mut o1 as *mut size_t,
                                          &mut o2 as *mut size_t,
@@ -181,7 +181,7 @@ pub fn print_mem_info(msg: String, device: i32) {
 /// # Return Values
 ///
 /// None
-pub fn set_mem_step_size(step_bytes: u64) {
+pub fn set_mem_step_size(step_bytes: usize) {
     unsafe {
         let err_val = af_set_mem_step_size(step_bytes as size_t);
         HANDLE_ERROR(AfError::from(err_val));
@@ -197,9 +197,9 @@ pub fn set_mem_step_size(step_bytes: u64) {
 /// # Return Values
 ///
 /// Returns is the size of minimum memory chunk in bytes
-pub fn get_mem_step_size() -> u64 {
+pub fn get_mem_step_size() -> usize {
     unsafe {
-        let mut temp: u64 = 0;
+        let mut temp: usize = 0;
         let err_val = af_get_mem_step_size(&mut temp as *mut size_t);
         HANDLE_ERROR(AfError::from(err_val));
         temp
@@ -228,4 +228,4 @@ pub fn sync(device: i32) {
         let err_val = af_sync(device as c_int);
         HANDLE_ERROR(AfError::from(err_val));
     }
-}
+}

src/util.rs

@@ -13,9 +13,9 @@ extern {
 }
 
 /// Get size, in bytes, of the arrayfire native type
-pub fn get_size(value: DType) -> u64 {
+pub fn get_size(value: DType) -> usize {
     unsafe {
-        let mut ret_val: u64 = 0;
+        let mut ret_val: usize = 0;
         let err_val = af_get_size_of(&mut ret_val as *mut size_t, value as uint8_t);
         HANDLE_ERROR(AfError::from(err_val));
         ret_val
@@ -29,37 +29,37 @@ impl From<i32> for AfError {
     }
 }
 
-impl From<u8> for DType {
-    fn from(t: u8) -> DType {
-        assert!(DType::F32 as u8 <= t && t <= DType::U64 as u8);
+impl From<i32> for DType {
+    fn from(t: i32) -> DType {
+        assert!(DType::F32 as i32 <= t && t <= DType::U64 as i32);
         unsafe { mem::transmute(t) }
     }
 }
 
-impl From<u8> for InterpType {
-    fn from(t: u8) -> InterpType {
-        assert!(InterpType::NEAREST as u8 <= t && t <= InterpType::CUBIC as u8);
+impl From<i32> for InterpType {
+    fn from(t: i32) -> InterpType {
+        assert!(InterpType::NEAREST as i32 <= t && t <= InterpType::CUBIC as i32);
         unsafe { mem::transmute(t) }
     }
 }
 
-impl From<u8> for ConvMode {
-    fn from(t: u8) -> ConvMode {
-        assert!(ConvMode::DEFAULT as u8 <= t && t <= ConvMode::EXPAND as u8);
+impl From<i32> for ConvMode {
+    fn from(t: i32) -> ConvMode {
+        assert!(ConvMode::DEFAULT as i32 <= t && t <= ConvMode::EXPAND as i32);
         unsafe { mem::transmute(t) }
     }
 }
 
-impl From<u8> for ConvDomain {
-    fn from(t: u8) -> ConvDomain {
-        assert!(ConvDomain::AUTO as u8 <= t && t <= ConvDomain::FREQUENCY as u8);
+impl From<i32> for ConvDomain {
+    fn from(t: i32) -> ConvDomain {
+        assert!(ConvDomain::AUTO as i32 <= t && t <= ConvDomain::FREQUENCY as i32);
         unsafe { mem::transmute(t) }
     }
 }
 
-impl From<u8> for MatchType {
-    fn from(t: u8) -> MatchType {
-        assert!(MatchType::SAD as u8 <= t && t <= MatchType::SHD as u8);
+impl From<i32> for MatchType {
+    fn from(t: i32) -> MatchType {
+        assert!(MatchType::SAD as i32 <= t && t <= MatchType::SHD as i32);
         unsafe { mem::transmute(t) }
     }
 }