include/algebramix/vector_unrolled.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_unrolled.hpp
* DESCRIPTION: loop unrolling within vectorial operations
* COPYRIGHT  : (C) 2007  Joris van der Hoeven and Gregoire Lecerf
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX__VECTOR_UNROLLED__HPP
#define __MMX__VECTOR_UNROLLED__HPP
#include <basix/basix.hpp>
#include <algebramix/vector_fixed.hpp>

namespace mmx {
#define TMPL  template<typename C>

/******************************************************************************
* Variant for loop unrolled routines on vectors
******************************************************************************/

template<nat len, typename V= vector_naive>
struct vector_unrolled: public V {
  typedef typename V::Naive Naive;
  typedef vector_unrolled<len,typename V::Aligned> Aligned;
  typedef vector_unrolled<len,typename V::No_simd> No_simd;
  typedef vector_unrolled<len,typename V::No_thread> No_thread;
};

template<typename F, typename V, nat len, typename W>
struct implementation<F,V,vector_unrolled<len,W> >:
  public implementation<F,V,W> {};

/******************************************************************************
* Abstract low level vector routines on vectors in memory
******************************************************************************/

template<typename V, nat len, typename W>
struct implementation<vector_abstractions,V,vector_unrolled<len,W> >:
  public implementation<vector_allocate,V>
{
  typedef implementation<vector_abstractions,W> Vec;

template<typename Op, typename T> static inline void
vec_nullary (T* dest, nat n) {
_loop:
  if (n<len) Vec::template vec_nullary<Op> (dest, n);
  else {
    vec_nullary_helper<Op, T, len>::op (dest);
    dest += len; n -= len;
    goto _loop;
  }
}

template<typename Op, typename T, typename C> static inline void
vec_unary (T* dest, const C* s, nat n) {
_loop:
  if (n<len) Vec::template vec_unary<Op> (dest, s, n);
  else {
    vec_unary_helper<Op, T, C, len>::op (dest, s);
    dest += len; s += len; n -= len;
    goto _loop;
  }
}

template<typename Op, typename T, typename C1, typename C2> static inline void
vec_binary (T* dest, const C1* s1, const C2* s2, nat n) {
_loop:
  if (n<len) Vec::template vec_binary<Op, T, C1, C2> (dest, s1, s2, n);
  else {
    vec_binary_helper<Op, T, C1, C2, len>::op (dest, s1, s2);
    dest += len; s1 += len; s2 += len; n -= len;
    goto _loop;
  }
}

template<typename Op, typename T, typename X> static inline void
vec_unary_scalar (T* dest, const X& x, nat n) {
_loop:
  if (n<len) Vec::template vec_unary_scalar<Op, T, X> (dest, x, n);
  else {
    vec_unary_scalar_helper<Op, T, X, len>::op (dest, x);
    dest += len; n -= len;
    goto _loop;
  }
}

template<typename Op, typename T, typename C, typename X> static inline void
vec_binary_scalar (T* dest, const C* s, const X& x, nat n) {
_loop:
  if (n<len) Vec::template vec_binary_scalar<Op, T, C, X> (dest, s, x, n);
  else {
    vec_binary_scalar_helper<Op, T, C, X, len>::op (dest, s, x);
    dest += len; s += len; n -= len;
    goto _loop;
  }
}

template<typename Op, typename C> static inline bool
vec_unary_test (const C* s, nat n) {
_loop:
  if (n<len) 
    return Vec::template vec_unary_test<Op, C> (s, n);
  else {
    if (! vec_unary_test_helper<Op, C, len>::op (s))
      return false;
    s += len; n -= len;
    goto _loop;
  }
  return true;
}

template<typename Op, typename C1, typename C2> static inline bool
vec_binary_test (const C1* s1, const C2* s2, nat n) {
_loop:
  if (n<len) 
    return Vec::template vec_binary_test<Op, C1, C2> (s1, s2, n);
  else {
    if (! vec_binary_test_helper<Op, C1, C2, len>::op (s1, s2))
      return false;
    s1 += len; s2 += len; n -= len;
    goto _loop;
  }
  return true;
}

template<typename Op, typename C, typename X> static inline bool
vec_binary_test_scalar (const C* s, const X& x, nat n) {
_loop:
  if (n<len)
    return Vec::template vec_binary_test_scalar<Op, C, X> (s, x, n);
  else {
    if (! vec_binary_test_scalar_helper<Op, C, X, len>::op (s, x))
      return false;
    s += len; n -= len;
    goto _loop;
  }
  return true;
}

template<typename Op, typename C> static inline Unary_return_type(Op,C)
vec_unary_big (const C* s, nat n) {
  typedef Unary_return_type(Op,C) R;
  if (n == 0) return Op::template neutral<C> ();
  R r= Op::template neutral<R> ();
  Op::set_op (r, Vec::template vec_unary_big<Op, C> (s, n));
  s++; n--;
_loop:
  if (n < len)
    Op::set_op (r, Vec::template vec_unary_big<Op, C> (s, n));
  else {
    vec_unary_big_helper<Op, R, C, len>::set_op (r, s);
    s += len; n -= len;
    goto _loop;
  }
  return r;
}

template<typename Op, typename C> static inline Unary_return_type(Op,C)
  vec_unary_big (const C* s, nat n, const format<C>& fm) {
  typedef Unary_return_type(Op,C) R;
  R r= get_sample (unary_map<Op> (fm));
  Op::set_neutral (r);
  if (n == 0) return r;
  Op::set_op (r, Vec::template vec_unary_big<Op, C> (s, n, fm));
  s++; n--;
_loop:
  if (n < len)
    Op::set_op (r, Vec::template vec_unary_big<Op, C> (s, n, fm));
  else {
    vec_unary_big_helper<Op, R, C, len>::set_op (r, s, fm);
    s += len; n -= len;
    goto _loop;
  }
  return r;
}

template<typename Op, typename C> static inline C
vec_unary_big_dicho (const C* s, nat n) {
  return vec_unary_big<Op, C> (s, n);
}

template<typename Op, typename C> static inline C
vec_unary_big_dicho (const C* s, nat n, const format<C>& fm) {
  return vec_unary_big<Op, C> (s, n, fm);
}

template<typename Op, typename C1, typename C2> static inline C1
vec_binary_big (const C1* s1, const C2* s2, nat n) {
  C1 r= Op::template neutral<C1> ();
_loop:
  if (n<len)
    for (; n != 0; s1++, s2++, n--)
      Op::set_op (r, *s1, *s2);
  else {
    vec_binary_big_helper<Op, C1, C2, len>::_op (r, s1, s2);
    s1 += len; s2 += len; n -= len;
    goto _loop;
  }
  return r;
}

template<typename Op, typename C1, typename C2> static inline C1
vec_binary_big (const C1* s1, const C2* s2, nat n,
                const format<C1>& fm1, const format<C2>& fm2) {
  C1 r= get_sample (binary_map<Op> (fm1, fm2));
  Op::set_neutral (r);
_loop:
  if (n<len)
    for (; n != 0; s1++, s2++, n--)
      Op::set_op (r, *s1, *s2);
  else {
    vec_binary_big_helper<Op, C1, C2, len>::_op (r, s1, s2, fm1, fm2);
    s1 += len; s2 += len; n -= len;
    goto _loop;
  }
  return r;
}

}; // implementation<vector_abstractions,V,vector_unrolled<len1,W> >

#undef TMPL
} // namespace mmx
#endif //__MMX__VECTOR_UNROLLED__HPP

---