Added mem_info macro

Moved the following macros to separate module(macros)

* mem_info
* join_many

Author: 9prady9

examples/pi.rs

@@ -1,3 +1,4 @@
+#[macro_use(mem_info)]
 extern crate arrayfire as af;
 extern crate time;
 
@@ -17,6 +18,8 @@ fn main() {
 
     let start = PreciseTime::now();
 
+    mem_info!("Before benchmark");
+
     for bench_iter in 0..100 {
         let pi_val = add(&mul(x, x, false).unwrap(), &mul(y, y, false).unwrap(), false)
             .and_then( |z| sqrt(&z) )
@@ -29,4 +32,6 @@ fn main() {
     let end = PreciseTime::now();
 
     println!("Estimated Pi Value in {} seconds", start.to(end) / 100);
+
+    mem_info!("After benchmark");
 }

src/data/mod.rs

@@ -395,55 +395,20 @@ pub fn join(dim: i32, first: &Array, second: &Array) -> Result<Array, AfError> {
 #[allow(unused_mut)]
 pub fn join_many(dim: i32, inputs: Vec<&Array>) -> Result<Array, AfError> {
     unsafe {
+        let mut v = Vec::new();
+        for i in inputs {
+            v.push(i.get());
+        }
         let mut temp: i64 = 0;
         let err_val = af_join_many(&mut temp as MutAfArray, dim as c_int,
-                                   inputs.len() as c_uint, inputs.as_ptr() as *const AfArray);
+                                   v.len() as c_uint, v.as_ptr() as *const AfArray);
         match err_val {
             0 => Ok(Array::from(temp)),
             _ => Err(AfError::from(err_val)),
         }
     }
 }
 
-/// Join multiple Arrays along a given dimension
-///
-/// # Examples
-///
-/// ```
-/// # #[macro_use] extern crate arrayfire;
-/// # fn main() {
-/// let a = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let b = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let c = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
-/// let d = join_many![2, a, b, c];
-/// # }
-/// ```
-///
-/// # Panics
-///
-/// Using this macro to create an Array from multiple Arrays doesn't implicitly check for errors
-/// during FFI calls. Therefore, make sure your inputs are correct. In case, you do need proper
-/// error checking, use the [function version](./fn.join_many.html) of this macro.
-// Using macro to implement join many wrapper
-#[macro_export]
-macro_rules! join_many {
-    [$dim: expr; $($x:ident),+] => {
-        {
-            let mut temp_vec = Vec::new();
-            $(
-                temp_vec.push($x);
-             )*
-            let mut temp: i64 = 0;
-            unsafe {
-                let mut temp: i64 = 0;
-                af_join_many(&mut temp as MutAfArray, $dim as c_int,
-                             temp_vec.len() as c_uint, temp_vec.as_ptr() as *const AfArray);
-                Array::from(temp)
-            }
-        }
-    };
-}
-
 macro_rules! data_func_def {
     ($fn_name:ident, $ffi_name: ident) => (
         #[allow(unused_mut)]

src/lib.rs

@@ -73,6 +73,7 @@ mod image;
 pub use lapack::{svd, lu, qr, cholesky, solve, solve_lu, inverse, det, rank, norm};
 pub use lapack::{svd_inplace, lu_inplace, qr_inplace, cholesky_inplace, is_lapack_available};
 mod lapack;
+mod macros;
 mod num;
 
 pub use signal::{approx1, approx2};

src/macros.rs

@@ -0,0 +1,91 @@
+/// Macro to print the current stats of ArrayFire's memory manager.
+///
+/// `mem_info!` print 4 values:
+///
+///  Name                    | Description
+/// -------------------------|-------------------------
+///  Allocated Bytes         | Total number of bytes allocated by the memory manager
+///  Allocated Buffers       | Total number of buffers allocated
+///  Locked (In Use) Bytes   | Number of bytes that are in use by active arrays
+///  Locked (In Use) Buffers | Number of buffers that are in use by active arrays
+///
+///  The `Allocated Bytes` is always a multiple of the memory step size. The
+///  default step size is 1024 bytes. This means when a buffer is to be
+///  allocated, the size is always rounded up to a multiple of the step size.
+///  You can use [get_mem_step_size](./fn.get_mem_step_size.html) to check the
+///  current step size and [set_mem_step_size](./fn.set_mem_step_size.html) to
+///  set a custom resolution size.
+///
+///  The `Allocated Buffers` is the number of buffers that use up the allocated
+///  bytes. This includes buffers currently in scope, as well as buffers marked
+///  as free, ie, from arrays gone out of scope. The free buffers are available
+///  for use by new arrays that might be created.
+///
+///  The `Locked Bytes` is the number of bytes in use that cannot be
+///  reallocated at the moment. The difference of Allocated Bytes and Locked
+///  Bytes is the total bytes available for reallocation.
+///
+///  The `Locked Buffers` is the number of buffer in use that cannot be
+///  reallocated at the moment. The difference of Allocated Buffers and Locked
+///  Buffers is the number of buffers available for reallocation.
+///
+/// # Parameters
+///
+/// - `msg` is the message that is printed to screen before printing stats
+///
+/// # Examples
+///
+/// ```
+/// mem_info!("Here");
+/// ```
+///
+/// Sample Output:
+///
+/// ```
+/// AF Memory: Here
+/// Allocated [ Bytes | Buffers ] = [ 4096 | 4 ]
+/// In Use    [ Bytes | Buffers ] = [ 2048 | 2 ]
+/// ```
+#[macro_export]
+macro_rules! mem_info {
+    [$msg: expr] => {
+        {
+            let (abytes, abuffs, lbytes, lbuffs) = device_mem_info().unwrap();
+            println!("AF Memory: {:?}", $msg);
+            println!("Allocated [Bytes | Buffers] = [ {} | {} ]", abytes, abuffs);
+            println!("In Use    [Bytes | Buffers] = [ {} | {} ]", lbytes, lbuffs);
+        }
+    };
+}
+
+/// Join multiple Arrays along a given dimension
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate arrayfire;
+/// # fn main() {
+/// let a = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+/// let b = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+/// let c = randu::<f32>(Dim4::new(&[5, 3, 1, 1])).unwrap();
+/// let d = join_many![2, a, b, c];
+/// # }
+/// ```
+///
+/// # Panics
+///
+/// This macro just calls [join_many](./fn.join_many.html) function after collecting all
+/// the input arrays into a vector.
+// Using macro to implement join many wrapper
+#[macro_export]
+macro_rules! join_many {
+    [$dim: expr; $($x:ident),+] => {
+        {
+            let mut temp_vec = Vec::new();
+            $(
+                temp_vec.push($x);
+             )*
+            join_many($dim, temp_vec)
+        }
+    };
+}