fix ref count for arrays used in indexing

The Array objects used by Indexer objects were not properly
incrementing the reference count. This led to memory corruption
and undefined behaviour which is fixed now.

Author: 9prady9

src/index.rs

@@ -5,34 +5,33 @@ use defines::AfError;
 use error::HANDLE_ERROR;
 use seq::Seq;
 use self::libc::{c_double, c_int, c_uint};
-use util::{AfArray, DimT, IndexT, MutAfArray, MutAfIndex};
+use util::{AfArray, AfIndex, DimT, MutAfArray, MutAfIndex};
 
 #[allow(dead_code)]
 extern {
     fn af_create_indexers(indexers: MutAfIndex) -> c_int;
-    fn af_set_array_indexer(indexer: MutAfIndex, idx: AfArray, dim: DimT) -> c_int;
-    fn af_set_seq_indexer(indexer: MutAfIndex, idx: *const SeqInternal, dim: DimT, is_batch: c_int) -> c_int;
-    fn af_release_indexers(indexers: MutAfIndex) -> c_int;
+    fn af_set_array_indexer(indexer: AfIndex, idx: AfArray, dim: DimT) -> c_int;
+    fn af_set_seq_indexer(indexer: AfIndex, idx: *const SeqInternal, dim: DimT, is_batch: c_int) -> c_int;
+    fn af_release_indexers(indexers: AfIndex) -> c_int;
 
     fn af_index(out: MutAfArray, input: AfArray, ndims: c_uint, index: *const SeqInternal) -> c_int;
     fn af_lookup(out: MutAfArray, arr: AfArray, indices: AfArray, dim: c_uint) -> c_int;
     fn af_assign_seq(out: MutAfArray, lhs: AfArray, ndims: c_uint, indices: *const SeqInternal, rhs: AfArray) -> c_int;
-    fn af_index_gen(out: MutAfArray, input: AfArray, ndims: DimT, indices: *const IndexT) -> c_int;
-    fn af_assign_gen(out: MutAfArray, lhs: AfArray, ndims: DimT, indices: *const IndexT, rhs: AfArray) -> c_int;
+    fn af_index_gen(out: MutAfArray, input: AfArray, ndims: DimT, indices: AfIndex) -> c_int;
+    fn af_assign_gen(out: MutAfArray, lhs: AfArray, ndims: DimT, indices: AfIndex, rhs: AfArray) -> c_int;
 }
 
 /// Struct to manage an array of resources of type `af_indexer_t`(ArrayFire C struct)
 pub struct Indexer {
     handle: i64,
-    count: u32,
 }
 
 // Trait that indicates that object can be used for indexing
 //
 // Any object to be able to be passed on to [./struct.Indexer.html#method.set_index] method
 // should implement this trait with appropriate implementation
 pub trait Indexable {
-    fn set(&self, idxr: &Indexer, dim: u32, is_batch: Option<bool>);
+    fn set(&self, idxr: &mut Indexer, dim: u32, is_batch: Option<bool>);
 }
 
 /// Enables [Array](./struct.Array.html) to be used to index another Array
@@ -41,11 +40,10 @@ pub trait Indexable {
 /// [assign_gen](./fn.assign_gen.html)
 impl Indexable for Array {
     #[allow(unused_variables)]
-    fn set(&self, idxr: &Indexer, dim: u32, is_batch: Option<bool>) {
+    fn set(&self, idxr: &mut Indexer, dim: u32, is_batch: Option<bool>) {
         unsafe {
-            let err_val = af_set_array_indexer(idxr.clone().get() as MutAfIndex,
-                                             self.get() as AfArray,
-                                             dim as DimT);
+            let err_val = af_set_array_indexer(idxr.get() as AfIndex, self.clone().get() as AfArray,
+                                               dim as DimT);
             HANDLE_ERROR(AfError::from(err_val));
         }
     }
@@ -56,9 +54,9 @@ impl Indexable for Array {
 /// This is used in functions [index_gen](./fn.index_gen.html) and
 /// [assign_gen](./fn.assign_gen.html)
 impl<T: Copy> Indexable for Seq<T> where c_double: From<T> {
-    fn set(&self, idxr: &Indexer, dim: u32, is_batch: Option<bool>) {
+    fn set(&self, idxr: &mut Indexer, dim: u32, is_batch: Option<bool>) {
         unsafe {
-            let err_val = af_set_seq_indexer(idxr.clone().get() as MutAfIndex,
+            let err_val = af_set_seq_indexer(idxr.get() as AfIndex,
                                              &SeqInternal::from_seq(self) as *const SeqInternal,
                                              dim as DimT, is_batch.unwrap() as c_int);
             HANDLE_ERROR(AfError::from(err_val));
@@ -74,33 +72,25 @@ impl Indexer {
             let mut temp: i64 = 0;
             let err_val = af_create_indexers(&mut temp as MutAfIndex);
             HANDLE_ERROR(AfError::from(err_val));
-            Indexer{handle: temp, count: 0}
+            Indexer{handle: temp}
         }
     }
 
     /// Set either [Array](./struct.Array.html) or [Seq](./struct.Seq.html) to index an Array along `idx` dimension
     pub fn set_index<T: Indexable>(&mut self, idx: &T, dim: u32, is_batch: Option<bool>) {
-        self.count = self.count + 1;
         idx.set(self, dim, is_batch)
     }
 
     /// Get native(ArrayFire) resource handle
     pub fn get(&self) -> i64 {
         self.handle
     }
-
-    /// Get number of indexers
-    ///
-    /// This can be a maximum of four since currently ArrayFire supports maximum of four dimensions
-    pub fn len(&self) -> u32 {
-        self.count
-    }
 }
 
 impl Drop for Indexer {
     fn drop(&mut self) {
         unsafe {
-            let ret_val = af_release_indexers(self.handle as MutAfIndex);
+            let ret_val = af_release_indexers(self.handle as AfIndex);
             match ret_val {
                 0 => (),
                 _ => panic!("Failed to release indexers resource: {}", ret_val),
@@ -338,7 +328,7 @@ pub fn index_gen(input: &Array, indices: Indexer) -> Array {
     unsafe{
         let mut temp: i64 = 0;
         let err_val = af_index_gen(&mut temp as MutAfArray, input.get() as AfArray,
-                                   indices.len() as DimT, indices.get() as *const IndexT);
+                                   4, indices.get() as AfIndex);
         HANDLE_ERROR(AfError::from(err_val));
         Array::from(temp)
     }
@@ -380,7 +370,7 @@ pub fn assign_gen(lhs: &Array, indices: &Indexer, rhs: &Array) -> Array {
     unsafe{
         let mut temp: i64 = 0;
         let err_val = af_assign_gen(&mut temp as MutAfArray, lhs.get() as AfArray,
-                                    indices.len() as DimT, indices.get() as *const IndexT,
+                                    4, indices.get() as AfIndex,
                                     rhs.get() as AfArray);
         HANDLE_ERROR(AfError::from(err_val));
         Array::from(temp)

src/util.rs

@@ -9,12 +9,12 @@ use self::num::Complex;
 use self::libc::{uint8_t, c_int, size_t, c_void};
 
 pub type AfArray       = self::libc::c_longlong;
+pub type AfIndex       = self::libc::c_longlong;
 pub type CellPtr       = *const self::libc::c_void;
 pub type Complex32     = Complex<f32>;
 pub type Complex64     = Complex<f64>;
 pub type DimT          = self::libc::c_longlong;
 pub type Feat          = *const self::libc::c_void;
-pub type IndexT        = self::libc::c_longlong;
 pub type Intl          = self::libc::c_longlong;
 pub type MutAfArray    = *mut self::libc::c_longlong;
 pub type MutAfIndex    = *mut self::libc::c_longlong;