ixdyn: Implement short-dimension optimization for IxDyn

This means that low-dimensional IxDyn are stored inline and don't need
an allocation for creation and cloning.

Author: bluss

src/aliases.rs

@@ -1,7 +1,14 @@
 //! Type aliases for common array sizes
 //!
 
-use ::{Ix, Array, ArrayView, ArrayViewMut, RcArray};
+use ::{
+    Ix,
+    Array,
+    ArrayView,
+    ArrayViewMut,
+    RcArray,
+    IxDynImpl,
+};
 use ::dimension::Dim;
 use dimension::DimPrivate;
 
@@ -78,7 +85,7 @@ pub type Ix6 = Dim<[Ix; 6]>;
 /// // the same type `Array<f64, IxDyn>` a.k.a `ArrayD<f64>`:
 /// let arrays = vec![a, b];
 /// ```
-pub type IxDyn = Dim<Vec<Ix>>;
+pub type IxDyn = Dim<IxDynImpl>;
 
 /// zero-dimensional array
 pub type Array0<A> = Array<A, Ix0>;

src/dimension/conversion.rs

@@ -11,7 +11,7 @@
 use std::ops::{Index, IndexMut};
 use libnum::Zero;
 
-use {Ix, Ix1, IxDyn, Dimension, Dim};
+use {Ix, Ix1, IxDyn, Dimension, Dim, IxDynImpl};
 use super::DimPrivate;
 
 /// $m: macro callback
@@ -56,12 +56,18 @@ impl<D> IntoDimension for D where D: Dimension {
     fn into_dimension(self) -> Self { self }
 }
 
-impl IntoDimension for Vec<usize> {
+impl IntoDimension for IxDynImpl {
     type Dim = IxDyn;
     #[inline(always)]
     fn into_dimension(self) -> Self::Dim { Dim::new(self) }
 }
 
+impl IntoDimension for Vec<Ix> {
+    type Dim = IxDyn;
+    #[inline(always)]
+    fn into_dimension(self) -> Self::Dim { Dim::new(IxDynImpl::from(self)) }
+}
+
 pub trait Convert {
     type To;
     fn convert(self) -> Self::To;

src/dimension/dimension_trait.rs

@@ -13,7 +13,7 @@ use std::ops::{Add, Sub, Mul, AddAssign, SubAssign, MulAssign};
 
 use itertools::{enumerate, zip};
 
-use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, IxDyn, Dim, Si};
+use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, IxDyn, Dim, Si, IxDynImpl};
 use IntoDimension;
 use RemoveAxis;
 use {ArrayView1, ArrayViewMut1};
@@ -53,7 +53,7 @@ pub unsafe trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     /// - For `Ix1`: `[Si; 1]`
     /// - For `Ix2`: `[Si; 2]`
     /// - and so on..
-    /// - For `Vec<Ix>`: `[Si]`
+    /// - For `IxDyn: `[Si]`
     ///
     /// The easiest way to create a `&SliceArg` is using the macro
     /// [`s![]`](macro.s!.html).
@@ -63,7 +63,7 @@ pub unsafe trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     /// - For `Ix1`: `usize`,
     /// - For `Ix2`: `(usize, usize)`
     /// - and so on..
-    /// - For `Vec<Ix>`: `Vec<usize>`,
+    /// - For `IxDyn: `IxDyn`
     type Pattern: IntoDimension<Dim=Self>;
     // Next smaller dimension (if it exists)
     #[doc(hidden)]
@@ -734,7 +734,7 @@ large_dim!(4, Ix4, Ix, Ix, Ix, Ix);
 large_dim!(5, Ix5, Ix, Ix, Ix, Ix, Ix);
 large_dim!(6, Ix6, Ix, Ix, Ix, Ix, Ix, Ix);
 
-/// Vec<Ix> is a "dynamic" index, pretty hard to use when indexing,
+/// IxDyn is a "dynamic" index, pretty hard to use when indexing,
 /// and memory wasteful, but it allows an arbitrary and dynamic number of axes.
 unsafe impl Dimension for IxDyn
 {
@@ -761,17 +761,17 @@ unsafe impl Dimension for IxDyn
     }
 }
 
-impl<J> Index<J> for Dim<Vec<usize>>
-    where Vec<usize>: Index<J>,
+impl<J> Index<J> for Dim<IxDynImpl>
+    where IxDynImpl: Index<J>,
 {
-    type Output = <Vec<usize> as Index<J>>::Output;
+    type Output = <IxDynImpl as Index<J>>::Output;
     fn index(&self, index: J) -> &Self::Output {
         &self.ix()[index]
     }
 }
 
-impl<J> IndexMut<J> for Dim<Vec<usize>>
-    where Vec<usize>: IndexMut<J>,
+impl<J> IndexMut<J> for Dim<IxDynImpl>
+    where IxDynImpl: IndexMut<J>,
 {
     fn index_mut(&mut self, index: J) -> &mut Self::Output {
         &mut self.ixm()[index]

src/dimension/dynindeximpl.rs

@@ -0,0 +1,180 @@
+
+use std::ops::{
+    Index,
+    IndexMut,
+    Deref,
+    DerefMut,
+};
+use imp_prelude::*;
+
+const CAP: usize = 4;
+
+/// T is usize or isize
+#[derive(Debug)]
+enum IxDynRepr<T> {
+    Inline(u32, [T; CAP]),
+    Alloc(Box<[T]>),
+}
+
+impl<T> Deref for IxDynRepr<T> {
+    type Target = [T];
+    fn deref(&self) -> &[T] {
+        match *self {
+            IxDynRepr::Inline(len, ref ar) => {
+                unsafe {
+                    ar.get_unchecked(..len as usize)
+                }
+            }
+            IxDynRepr::Alloc(ref ar) => &*ar,
+        }
+    }
+}
+
+impl<T> DerefMut for IxDynRepr<T> {
+    fn deref_mut(&mut self) -> &mut [T] {
+        match *self {
+            IxDynRepr::Inline(len, ref mut ar) => {
+                unsafe {
+                    ar.get_unchecked_mut(..len as usize)
+                }
+            }
+            IxDynRepr::Alloc(ref mut ar) => &mut *ar,
+        }
+    }
+}
+
+impl Default for IxDynRepr<Ix> {
+    fn default() -> Self {
+        Self::copy_from(&[0])
+    }
+}
+
+
+use ::libnum::Zero;
+
+impl<T: Copy + Zero> IxDynRepr<T> {
+    pub fn copy_from(x: &[T]) -> Self {
+        if x.len() <= CAP {
+            let mut arr = [T::zero(); CAP];
+            for i in 0..x.len() {
+                arr[i] = x[i];
+            }
+            IxDynRepr::Inline(x.len() as _, arr)
+        } else {
+            Self::from(x)
+        }
+    }
+}
+
+impl<T: Copy + Zero> IxDynRepr<T> {
+    // make an Inline or Alloc version as appropriate
+    fn from_vec_auto(v: Vec<T>) -> Self {
+        if v.len() <= CAP {
+            Self::copy_from(&v)
+        } else {
+            Self::from_vec(v)
+        }
+    }
+}
+
+impl<T: Copy> IxDynRepr<T> {
+    fn from_vec(v: Vec<T>) -> Self {
+        IxDynRepr::Alloc(v.into_boxed_slice())
+    }
+
+    fn from(x: &[T]) -> Self {
+        Self::from_vec(x.to_vec())
+    }
+}
+
+impl<T: Copy> Clone for IxDynRepr<T> {
+    fn clone(&self) -> Self {
+        match *self {
+            IxDynRepr::Inline(len, arr) => {
+                IxDynRepr::Inline(len, arr)
+            }
+            _ => Self::from(&self[..])
+        }
+    }
+}
+
+impl<T: Eq> Eq for IxDynRepr<T> { }
+
+impl<T: PartialEq> PartialEq for IxDynRepr<T> {
+    fn eq(&self, rhs: &Self) -> bool {
+        match (self, rhs) {
+            (&IxDynRepr::Inline(slen, ref sarr), &IxDynRepr::Inline(rlen, ref rarr)) => {
+                slen == rlen &&
+                    (0..CAP as usize).filter(|&i| i < slen as usize)
+                        .all(|i| sarr[i] == rarr[i])
+            }
+            _ => self[..] == rhs[..]
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct IxDynImpl(IxDynRepr<Ix>);
+unsafe impl Send for IxDynImpl {}
+unsafe impl Sync for IxDynImpl {}
+
+impl IxDynImpl {
+    pub fn remove(&mut self, i: usize) {
+        unimplemented!()
+    }
+}
+
+impl<'a> From<&'a [Ix]> for IxDynImpl {
+    #[inline]
+    fn from(ix: &'a [Ix]) -> Self {
+        IxDynImpl(IxDynRepr::copy_from(ix))
+    }
+}
+
+impl From<Vec<Ix>> for IxDynImpl {
+    #[inline]
+    fn from(ix: Vec<Ix>) -> Self {
+        IxDynImpl(IxDynRepr::from_vec_auto(ix))
+    }
+}
+
+impl<J> Index<J> for IxDynImpl
+    where [Ix]: Index<J>,
+{
+    type Output = <[Ix] as Index<J>>::Output;
+    fn index(&self, index: J) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+impl<J> IndexMut<J> for IxDynImpl
+    where [Ix]: IndexMut<J>,
+{
+    fn index_mut(&mut self, index: J) -> &mut Self::Output {
+        &mut self.0[index]
+    }
+}
+
+impl Deref for IxDynImpl {
+    type Target = [Ix];
+    #[inline]
+    fn deref(&self) -> &[Ix] {
+        &self.0
+    }
+}
+
+impl DerefMut for IxDynImpl {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut [Ix] {
+        &mut self.0
+    }
+}
+
+impl<'a> IntoIterator for &'a IxDynImpl {
+    type Item = &'a Ix;
+    type IntoIter = <&'a [Ix] as IntoIterator>::IntoIter;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self[..].into_iter()
+    }
+}

src/dimension/mod.rs

@@ -17,12 +17,14 @@ pub use self::dimension_trait::Dimension;
 pub use self::ndindex::NdIndex;
 pub use self::remove_axis::RemoveAxis;
 pub use self::axes::{axes_of, Axes, AxisDescription};
+pub use self::dynindeximpl::IxDynImpl;
 
 #[macro_use] mod macros;
 mod axis;
 mod conversion;
 pub mod dim;
 mod dimension_trait;
+mod dynindeximpl;
 mod ndindex;
 mod remove_axis;
 mod axes;

src/dimension/ndindex.rs

@@ -4,6 +4,9 @@ use std::fmt::Debug;
 use itertools::zip;
 
 use {Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, Dimension, IntoDimension};
+use {
+    IxDynImpl,
+};
 use super::{stride_offset, stride_offset_checked};
 use super::DimPrivate;
 
@@ -194,9 +197,9 @@ ndindex_with_array!{
 }
 
 impl<'a> IntoDimension for &'a [Ix] {
-    type Dim = Dim<Vec<Ix>>;
+    type Dim = IxDyn;
     fn into_dimension(self) -> Self::Dim {
-        Dim(self.to_vec())
+        Dim(IxDynImpl::from(self))
     }
 }
 
@@ -209,7 +212,7 @@ unsafe impl<'a> NdIndex<IxDyn> for &'a [Ix] {
     }
 }
 
-unsafe impl NdIndex<IxDyn> for Vec<Ix> {
+unsafe impl NdIndex<IxDyn> for IxDynImpl {
     fn index_checked(&self, dim: &IxDyn, strides: &IxDyn) -> Option<isize> {
         stride_offset_checked(dim.ix(), strides.ix(), self)
     }

src/dimension/remove_axis.rs

@@ -8,6 +8,7 @@
 
 
 use {Ix, Ix0, Ix1, Dimension, Dim, Axis};
+use IxDyn;
 use super::DimPrivate;
 
 /// Array shape with a next smaller dimension.
@@ -66,7 +67,7 @@ macro_rules! impl_remove_axis_array(
 impl_remove_axis_array!(3, 4, 5, 6);
 
 
-impl RemoveAxis for Dim<Vec<Ix>> {
+impl RemoveAxis for IxDyn {
     type Smaller = Self;
     fn remove_axis(&self, axis: Axis) -> Self {
         let mut res = self.clone();

src/lib.rs

@@ -94,6 +94,7 @@ pub use dimension::{
 pub use dimension::dim::*;
 
 pub use dimension::NdIndex;
+pub use dimension::IxDynImpl;
 pub use indexes::Indices;
 pub use indexes::{indices, indices_of};
 pub use error::{ShapeError, ErrorKind};