Added wrappers around af_alloc_host and af_free_host in the util module.

Author: botev

src/device/mod.rs

@@ -3,7 +3,8 @@ extern crate libc;
 use defines::{AfError, DType};
 use error::HANDLE_ERROR;
 use self::libc::{c_int, size_t, c_char, c_void};
-use std::ffi::CString;
+use std::ffi::{CStr, CString};
+use util::free_host;
 
 extern {
     fn af_get_version(major: *mut c_int, minor: *mut c_int, patch: *mut c_int) -> c_int;
@@ -21,9 +22,6 @@ extern {
     fn af_get_mem_step_size(step_bytes: *mut size_t) -> c_int;
     fn af_device_gc() -> c_int;
     fn af_sync(device: c_int) -> c_int;
-
-    fn af_alloc_host(elements: size_t, _type: DType) -> *mut c_void;
-    fn af_free_host(ptr: *mut c_void) -> c_int;
 }
 
 /// Get ArrayFire Version Number
@@ -72,17 +70,15 @@ pub fn info() {
 /// [0] GeForce GT 750M, 2048 MB, CUDA Compute 3.0
 /// ```
 pub fn info_string(verbose: bool) -> String {
-    let mut tmp: *mut c_char = 0 as *mut c_char;
+    let result: String;
     unsafe {
+        let mut tmp: *mut c_char = 0 as *mut c_char;
         let err_val = af_info_string(&mut tmp, verbose);
         HANDLE_ERROR(AfError::from(err_val));
-
-        let result = (*CString::from_raw(tmp)).to_str().unwrap().to_owned();
-
-        let err_val = af_free_host(tmp as *mut c_void);
-        HANDLE_ERROR(AfError::from(err_val));
-        result
+        result = CStr::from_ptr(tmp).to_string_lossy().into_owned();
+        free_host(tmp);
     }
+    result
 }
 
 /// Initialize ArrayFire library

src/util.rs

@@ -6,11 +6,18 @@ use defines::{SparseFormat, BinaryOp, RandomEngineType};
 use error::HANDLE_ERROR;
 use std::mem;
 use self::num::Complex;
-use self::libc::{uint8_t, c_int, size_t};
+use self::libc::{uint8_t, c_int, size_t, c_void};
+
+// This is private in array
+// use array::DimT;
+type DimT = self::libc::c_longlong;
 
 #[allow(dead_code)]
 extern {
     fn af_get_size_of(size: *mut size_t, aftype: uint8_t) -> c_int;
+
+    fn af_alloc_host(ptr: *mut *const c_void, bytes: DimT) -> c_int;
+    fn af_free_host(ptr: *mut c_void) -> c_int;
 }
 
 /// Get size, in bytes, of the arrayfire native type
@@ -23,6 +30,25 @@ pub fn get_size(value: DType) -> usize {
     }
 }
 
+/// Allocates space using Arrayfire allocator in host memory
+pub fn alloc_host<T>(elements: usize, _type: DType) -> *const T {
+    let ptr = 0 as *const T;
+    let bytes = (elements * get_size(_type)) as DimT;
+    unsafe {
+        let err_val = af_alloc_host(&mut (ptr as *const c_void), bytes);
+        HANDLE_ERROR(AfError::from(err_val));
+    }
+    ptr
+}
+
+/// Frees memory allocated by Arrayfire allocator in host memory
+pub fn free_host<T>(ptr: *mut T) {
+    unsafe {
+        let err_val = af_free_host(ptr as *mut c_void);
+        HANDLE_ERROR(AfError::from(err_val));
+    }
+}
+
 impl From<i32> for AfError {
     fn from(t: i32) -> AfError {
         assert!(AfError::SUCCESS as i32 <= t && t <= AfError::ERR_UNKNOWN as i32);