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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : modular_simd.hpp
* DESCRIPTION: SIMD support for modulars
* COPYRIGHT  : (C) 2007  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__MODULAR_SIMD__HPP
#define __MMX__MODULAR_SIMD__HPP
#include <basix/int.hpp>
#include <numerix/simd.hpp>
#include <numerix/sse.hpp>
#include <numerix/modular.hpp>
#ifdef NUMERIX_ENABLE_SIMD
#include <algebramix/vector_fixed.hpp>

namespace mmx {

/******************************************************************************
* Helpers
******************************************************************************/

template<typename M>
struct simd_modulus_helper;
  
template<typename M, typename W>
struct simd_modulus_helper<modular<M,W> > {
  typedef typename M::base C;
  typedef typename simd_helper<C>::type simd_C;
  static inline C get_modulus () {
    return *modular<M,W>::get_modulus (); }
  static inline simd_C modulus_duplicate () {
    static const simd_C vp = simd_set_duplicate (get_modulus ());
    return vp; }
};

template<typename C, typename V, typename X, X p>
struct simd_modulus_helper <modular<modulus<C,V>, modular_fixed<X,p> > > {
  typedef modulus<C,V> M;
  typedef modular_fixed<X,p> W;
  typedef typename simd_helper<C>::type simd_C;
  static inline C get_modulus () {
    static const C np = *modular<M,W>::get_modulus ();
    return np; }
  static inline simd_C modulus_duplicate () {
    static const simd_C vp = simd_set_duplicate (get_modulus ());
    return vp; }
};

/******************************************************************************
* modulars over int8_t
******************************************************************************/

#ifdef __SSSE3__

template<typename R, nat n>
struct vec_neg_mod_simd_helper {};

template<typename R, nat n>
struct vec_add_mod_simd_helper {};

template<typename R, nat n>
struct vec_sub_mod_simd_helper {};

template<typename V, typename W>
struct vec_neg_mod_simd_helper<modular<modulus<int8_t, V>, W>,
                               Simd_size (int8_t)> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s,
                         const simd_C& vp, const simd_C& vz) {
    simd_C vs, vd;
    vs = simd_load_aligned ((C*) s);
    vd = - vs;
    vs = vd + vp;
    vd = _mm_min_epu8 ((__m128i) vd, (__m128i) vs);
    simd_save_aligned ((C*) dest, vd);
  }
};

template<typename V, typename W, nat n>
struct vec_neg_mod_simd_helper<modular<modulus<int8_t, V>, W>, n> {
  static const nat n1= (n>>1), n2= n-n1;
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s,
                         const simd_C& vp, const simd_C& vz) {
    vec_neg_mod_simd_helper <R, n1>::op (dest   , s   , vp, vz);
    vec_neg_mod_simd_helper <R, n2>::op (dest+n1, s+n1, vp, vz);
  }
};

template<typename V, typename W, nat n>
struct vec_unary_helper<neg_op,
                        modular<modulus<int8_t, V>, W>,
                        modular<modulus<int8_t, V>, W>,
                        n> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s) {
    const simd_C vz = simd_set_duplicate ((C) 0);
    const simd_C vp = simd_modulus_helper<R>::modulus_duplicate ();
    vec_neg_mod_simd_helper<R, n>:: op (dest, s, vp, vz);
  }
};

template<typename V, typename W>
struct vec_add_mod_simd_helper<modular<modulus<int8_t, V>, W>,
                               Simd_size (int8_t)> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2,
                         const simd_C& vp, const simd_C& vz) {
    simd_C v1, v2, vd;
    v1 = simd_load_aligned ((C*) s1);
    v2 = simd_load_aligned ((C*) s2);
    vd = v1 + v2;
    vd = _mm_min_epu8 ((__m128i) vd, (__m128i) (vd - vp));
    simd_save_aligned ((C*) dest, vd);
  }
};

template<typename V, typename W, nat n>
struct vec_add_mod_simd_helper<modular<modulus<int8_t, V>, W>, n> {
  static const nat n1= (n>>1), n2= n-n1;
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2,
                         const simd_C& vp, const simd_C& vz) {
    vec_add_mod_simd_helper <R, n1>::op (dest   , s1   , s2,    vp, vz);
    vec_add_mod_simd_helper <R, n2>::op (dest+n1, s1+n1, s2+n1, vp, vz);
  }
};

template<typename V, typename W, nat n>
struct vec_binary_helper<add_op,
                        modular<modulus<int8_t, V>, W>,
                        modular<modulus<int8_t, V>, W>,
                        modular<modulus<int8_t, V>, W>,
                        n> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2) {
    const simd_C vz = simd_set_duplicate ((C) 0);
    const simd_C vp = simd_modulus_helper<R>::modulus_duplicate ();
    vec_add_mod_simd_helper<R, n>:: op (dest, s1, s2, vp, vz);
  }
};

template<typename V, typename W>
struct vec_sub_mod_simd_helper<modular<modulus<int8_t, V>, W>,
                               Simd_size (int8_t)> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2,
                         const simd_C& vp) {
    simd_C v1, v2, vd;
    v1 = simd_load_aligned ((C*) s1);
    v2 = simd_load_aligned ((C*) s2);
    vd = v1 - v2;
    vd = _mm_min_epu8 ((__m128i) vd, (__m128i) (vd + vp));
    simd_save_aligned ((C*) dest, vd);
  }
};

template<typename V, typename W, nat n>
struct vec_sub_mod_simd_helper<modular<modulus<int8_t, V>, W>, n> {
  static const nat n1= (n>>1), n2= n-n1;
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2,
                         const simd_C& vp) {
    vec_sub_mod_simd_helper <R, n1>::op (dest   , s1   , s2,    vp);
    vec_sub_mod_simd_helper <R, n2>::op (dest+n1, s1+n1, s2+n1, vp);
  }
};

template<typename V, typename W, nat n>
struct vec_binary_helper<sub_op,
                        modular<modulus<int8_t, V>, W>,
                        modular<modulus<int8_t, V>, W>,
                        modular<modulus<int8_t, V>, W>,
                        n> {
  typedef int8_t C;
  typedef typename simd_helper<C>::type simd_C;
  typedef modulus<C, V> M;
  typedef modular<M, W> R;

  static inline void op (R* dest, const R* s1, const R* s2) {
    const simd_C vp = simd_modulus_helper<R>::modulus_duplicate ();
    vec_sub_mod_simd_helper<R, n>:: op (dest, s1, s2, vp);
  }
};

#endif // __SSSE3__

} // namespace mmx

#endif // NUMERIX_ENABLE_SIMD
#endif // __MMX__MODULAR_SIMD__HPP