/Users/mourrain/Devel/mmx/algebramix/include/algebramix/vector_sse.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : vector_sse.hpp
* DESCRIPTION: SSE instructions support for aligned vectors
* COPYRIGHT  : (C) 2008  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_SSE__HPP
#define __MMX__VECTOR_SSE__HPP

#include <basix/operators.hpp>
#include <basix/double.hpp>
#include <numerix/sse.hpp>
#include <algebramix/algebramix-config.hpp>
#include <algebramix/vector_aligned.hpp>

#ifndef NUMERIX_ENABLE_SIMD
#undef ALGEBRAMIX_ENABLE_SIMD
#endif

namespace mmx {
#ifdef ALGEBRAMIX_ENABLE_SIMD

/******************************************************************************
* SSE features helpers
******************************************************************************/

// According to basix/fast_new.hpp, any allocation of size
// being a multiple of 16 bytes is aligned.

#ifdef __SSE2__

template<typename Op, typename C>
struct sse_has_helper { static const bool value= false;};

template<typename C>
struct sse_has_helper<id_op, C> {static const bool value= true;};

STMPL
struct sse_has_helper<equal_op, double> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, int8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, uint8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, int16_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, uint16_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, int32_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, uint32_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, int64_t> {static const bool value= true;};
STMPL
struct sse_has_helper<equal_op, uint64_t> {static const bool value= true;};

template<typename C>
struct sse_has_helper<neg_op, C> {static const bool value= true;};

template<typename C>
struct sse_has_helper<add_op, C> {static const bool value= true;};

template<typename C>
struct sse_has_helper<sub_op, C> {static const bool value= true;};

STMPL
struct sse_has_helper<mul_op, double> {static const bool value= true;};
STMPL
struct sse_has_helper<mul_op, int8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<mul_op, uint8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<mul_op, int16_t> {static const bool value= true;};
STMPL
struct sse_has_helper<mul_op, uint16_t> {static const bool value= true;};

template<typename C>
struct sse_has_helper<lmul_op, C> {
  static const bool value= sse_has_helper<mul_op,C>::value; };

template<typename C>
struct sse_has_helper<rmul_op, C> {
  static const bool value= sse_has_helper<mul_op,C>::value; };

STMPL
struct sse_has_helper<div_op, double> {static const bool value= true;};

template<typename C>
struct sse_has_helper<ldiv_op, C> {
  static const bool value= sse_has_helper<div_op,C>::value; };

template<typename C>
struct sse_has_helper<rdiv_op, C> {
  static const bool value= sse_has_helper<div_op,C>::value; };

template<typename C>
struct sse_has_helper<mul_add_op, C> {
  static const bool value= sse_has_helper<add_op,C>::value &&
                           sse_has_helper<mul_op,C>::value; };

STMPL
struct sse_has_helper<min_op, uint8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<min_op, int16_t> {static const bool value= true;};

STMPL
struct sse_has_helper<max_op, uint8_t> {static const bool value= true;};
STMPL
struct sse_has_helper<max_op, int16_t> {static const bool value= true;};

/******************************************************************************
* SSE support for aligned vectors
******************************************************************************/

// Unary
template<bool b, typename V, typename W, typename Op, typename C>
struct vec_unary_simd_helper {
  typedef implementation<vector_abstractions,V> Vec;
  static inline void op (C* dest, const C* s, nat n) {
    Vec::template vec_unary<Op, C, C> (dest, s, n); }
};

template<typename V, typename W, typename Op, typename C>
struct vec_unary_simd_helper <true,V,W,Op,C> {
  static inline void op (C* dest, const C* s, nat n) {
    typedef typename Simd_type (C) simd_C;
    typedef implementation<vector_abstractions,W> SVec;
    static const nat m= Simd_size (C);
    SVec::template vec_unary<Op, simd_C, simd_C>
      ((simd_C*) dest, (simd_C*) s, n / m); }
};

template<typename V, typename W, typename Op, typename C>
struct vec_unary_aligned_helper <V,W,Op,C,C> :
    vec_unary_simd_helper <sse_has_helper<Op, C>::value,V,W,Op,C> {};

// Binary
template<bool b, typename V, typename W, typename Op, typename C>
struct vec_binary_simd_helper {
  static inline void op (C* dest, const C* s1, const C* s2, nat n) {
    typedef implementation<vector_abstractions,V> Vec;
      Vec::template vec_binary<Op, C, C, C> (dest, s1, s2, n); }
};

template<typename V, typename W, typename Op, typename C>
struct vec_binary_simd_helper <true,V,W,Op,C> {
  static inline void op (C* dest, const C* s1, const C* s2, nat n) {
    typedef typename Simd_type (C) simd_C;
    typedef implementation<vector_abstractions,W> SVec;
    static const nat m= Simd_size (C);
    SVec::template vec_binary<Op, simd_C, simd_C, simd_C>
      ((simd_C*) dest, (simd_C*) s1, (simd_C*) s2, n / m); }
};

template<typename V, typename W,typename Op, typename C>
struct vec_binary_aligned_helper <V,W,Op,C,C,C> :
    vec_binary_simd_helper <sse_has_helper<Op, C>::value,V,W,Op,C> {};

// Binary scalar
template<bool b, typename V, typename W, typename Op, typename C>
struct vec_binary_scalar_simd_helper {
  static inline void op (C* dest, const C* s, const C& x, nat n) {
    typedef implementation<vector_abstractions,V> Vec;
    Vec::template vec_binary_scalar<Op, C, C, C > (dest, s, x, n); }
};

template<typename V, typename W, typename Op, typename C>
struct vec_binary_scalar_simd_helper <true,V,W,Op,C> {
  static inline void op (C* dest, const C* s, const C& x, nat n) {
    typedef typename Simd_type (C) simd_C;
    typedef implementation<vector_abstractions,W> SVec;
    static const nat m= Simd_size (C);
    simd_C vx= simd_set_duplicate (x);
    SVec::template vec_binary_scalar<Op, simd_C, simd_C, simd_C >
      ((simd_C*) dest, (simd_C*) s, vx, n / m); }
};

template<typename V, typename W, typename Op, typename C>
struct vec_binary_scalar_aligned_helper <V,W,Op,C,C,C> :
    vec_binary_scalar_simd_helper <sse_has_helper<Op, C>::value,V,W,Op,C> {};

#if 0
  // problem with neutral on simd types. FIXME
template<typename V, typename W, typename C>
struct vec_binary_big_aligned_helper<V,W,mul_add_op,C,C> {
  static inline C op (const C* s1, const C* s2, nat n) {
    typedef typename Simd_type (C) simd_C;
    typedef implementation<vector_abstractions,V> Vec;
    typedef implementation<vector_abstractions,W> SVec;
    static const nat m= Simd_size (C);
    if (sse_has_helper<mul_add_op, C>::value && m > 1) {
      simd_C vr= SVec::template vec_binary_big<mul_add_op, simd_C, simd_C>
        ((simd_C*) s1, (simd_C*) s2, n / m);
      return simd_big_add<C> (vr);
    }
    else
      return Vec::template vec_binary_big<mul_add_op, C, C> (s1, s2, n); }
};
#endif
#endif // __SSE2__
#endif // ALGEBRAMIX_ENABLE_SIMD
} // namespace mmx

#endif // __MMX__VECTOR_SSE__HPP