utils.h

Go to the documentation of this file.

#ifndef AMPGEN_SIMD_UTILS_H
#define AMPGEN_SIMD_UTILS_H
 
#include <array>
#include <complex>
#include "AmpGen/Complex.h"
 
#define INSTRUCTION_SET_SCALAR   0 
#define INSTRUCTION_SET_AVX2f    1 
#define INSTRUCTION_SET_AVX2d    2 
#define INSTRUCTION_SET_AVX512d  3 
#define INSTRUCTION_SET_ARM128d 10
 
 
#if INSTRUCTION_SET == INSTRUCTION_SET_SCALAR
  namespace scalar { using real_v = double; using complex_v = std::complex<double>; } 
#elif INSTRUCTION_SET == INSTRUCTION_SET_AVX2f
//  #pragma message("Enable AVX2f")
  #include "AmpGen/simd/avx2f_types.h"
#elif INSTRUCTION_SET == INSTRUCTION_SET_AVX2d
//  #pragma message("Enable AVX2d")
  #include "AmpGen/simd/avx2d_types.h"
#elif INSTRUCTION_SET == INSTRUCTION_SET_AVX512d
//  #pragma message("Enable AVX512d")
  #include "AmpGen/simd/avx512d_types.h"
#elif INSTRUCTION_SET == INSTRUCTION_SET_ARM128d
  #include "AmpGen/simd/arm128d_types.h"
#else 
  #pragma message("Unrecognised instruction set")
#endif
 
namespace AmpGen {
 
#if INSTRUCTION_SET == INSTRUCTION_SET_AVX512d
  namespace AVX        = AVX512d;
#elif INSTRUCTION_SET == INSTRUCTION_SET_AVX2d
  namespace AVX        = AVX2d;
#elif INSTRUCTION_SET == INSTRUCTION_SET_AVX2f
  namespace AVX        = AVX2f;
#elif INSTRUCTION_SET == INSTRUCTION_SET_SCALAR
  namespace AVX        = scalar; 
#elif INSTRUCTION_SET == INSTRUCTION_SET_ARM128d
  namespace AVX        = ARM128d; 
#endif
 
  using real_v      = AVX::real_v;
  using complex_v   = AVX::complex_v; 
  namespace utils {
 
    template <typename T> struct is_vector_type : std::false_type {}; 
    template <typename T> struct size           { static constexpr unsigned value = 1; } ;
    template <typename T> struct is_complex_type : std::false_type {}; 
    template <typename T> struct is_complex_type<AmpGen::Complex<T>> : std::true_type {}; 
 
    #if INSTRUCTION_SET != 0 
        template <>        struct is_vector_type <complex_v> : std::true_type {}; 
        template <>        struct is_vector_type <real_v  >  : std::true_type {}; 
        template <>        struct size           <complex_v>{ static constexpr unsigned value = real_v::size; }; 
        template <>        struct size           <real_v>   { static constexpr unsigned value = real_v::size; }; 
    #endif
    #if INSTRUCTION_SET == INSTRUCTION_SET_ARM128d
        template <>        struct size           <AVX::int_v>   { static constexpr unsigned value = 2; };
        template <>        struct is_vector_type <AVX::int_v>   : std::true_type {}; 
    #endif
    template <typename simd_type, typename container_type, typename functor_type> simd_type gather(
        const container_type& container, const functor_type& functor, unsigned offset=0, typename simd_type::scalar_type df =0.)
    {
      std::array<typename simd_type::scalar_type, simd_type::size> rv; 
      if( df == 0. )
      for( unsigned k = 0 ; k != simd_type::size; ++k ) rv[k] = offset + k < container.size() ? functor(container[offset+k]) : functor(container[container.size()-1]); 
      else 
      for( unsigned k = 0 ; k != simd_type::size; ++k ) rv[k] = offset + k < container.size() ? functor(container[offset+k]) : df; 
      return simd_type( rv.data() );
    } 
    template <typename simd_type, typename container_type, typename functor_type> simd_type gather( {…}
 
    template <typename simd_type> size_t aligned_size( const size_t& unaligned_size ) {
      return size<simd_type>::value * unsigned ( 1 + (unaligned_size -1 ) / size<simd_type>::value );
    }
    template <typename simd_type> size_t aligned_size( const size_t& unaligned_size ) {…}
    template <typename simd_type> auto sum_elements( const simd_type& obj )
    {
      if constexpr ( is_vector_type<simd_type>::value and std::is_same_v<simd_type, real_v> )
      {
        const auto arr = obj.to_ptr();
        auto rt = arr[0];
        for( unsigned i = 1 ; i != size<simd_type>::value; ++i ) rt += arr[i];
        return rt;
      }
      else return obj;
    }
    template <typename simd_type> auto sum_elements( const simd_type& obj ) {…}
    template <typename simd_type> bool all_of( const simd_type& obj)
    {
      if constexpr( size<simd_type>::value == 1 ) return obj;
      #if INSTRUCTION_SET == INSTRUCTION_SET_AVX2d
        return _mm256_movemask_pd( obj ) == 0xF;
      #elif INSTRUCTION_SET == INSTRUCTION_SET_AVX2f
        return _mm256_movemask_ps( obj ) == 0xFF;
      #endif
      return false; 
    }
    template <typename simd_type> bool all_of( const simd_type& obj) {…}
    template <typename simd_type, typename value_type> bool all_of( const simd_type& obj, const value_type& v )
    {
      return all_of( obj == v );
    }
    template <typename simd_type, typename value_type> bool all_of( const simd_type& obj, const value_type& v ) {…}
    template <typename T> auto make_complex( T&& re, T&& im ) { return std::complex<T>(re,im); }
    template <unsigned p=0, typename vtype> auto get( vtype v )
    { 
      if constexpr (  is_complex_type<vtype>::value ) return std::complex( get<p>(v.real() ), get<p>(v.imag() ) );
      else if constexpr (  is_vector_type<vtype>::value ) return v.at(p); 
      else if constexpr ( std::is_same<vtype, complex_v>::value ) return std::complex( get<p>(v.real()), get<p>(v.imag()) );
      else if constexpr ( !is_vector_type<vtype>::value ) return v; 
    }
    template <unsigned p=0, typename vtype> auto get( vtype v ) {…}
    template < typename vtype> auto at( vtype v, const unsigned p=0 )
    {
      if constexpr ( is_vector_type<vtype>::value )
      {
        if constexpr ( std::is_same<vtype, real_v>::value ) return v.at(p);
        if constexpr ( std::is_same<vtype, complex_v>::value ) return std::complex( at( v.real(), p), at( v.imag(), p) );
      }
      else return v; 
    }
    template < typename vtype> auto at( vtype v, const unsigned p=0 ) {…}
    template <typename>   struct is_std__complex : std::false_type{};
    template <typename T> struct is_std__complex<std::complex<T>> : std::true_type {} ; 
 
    template <typename T> inline auto norm( T&& value ){ 
      if constexpr( is_std__complex<std::remove_reference_t<T>> ::value ){ return std::norm(value); }
      else { return value.norm(); }
    }
    template <typename T> inline auto norm( T&& value ) {…}
 
    template <typename type, typename store_type> void store( store_type* container, const type& v)
    {
      if constexpr( is_vector_type<type>::value ) 
      {
        auto arr = v.to_ptr();
        for( unsigned k = 0 ; k != utils::size<type>::value; ++k ) container[k] =  arr[k];
      }
      else {
        *container = v;
      }
    }
    template <typename type, typename store_type> void store( store_type* container, const type& v) {…}
  }
  namespace utils {…}
}
 
#endif