vectorization.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

#ifdef __ARM_ARCH
#include <arm_neon.h>
#else
#include <immintrin.h>
#endif 


#include "etl/inline.hpp"

namespace etl {

constexpr ETL_STRONG_INLINE(size_t) prev_multiple(size_t N, size_t size) {
    return N & (size_t(-size));
}

template <vector_mode_t V, typename T, typename VT>
struct simd_pack {
    using value_type     = T;  
    using intrinsic_type = VT; 

    static constexpr vector_mode_t vector_mode = V; 

    intrinsic_type value; 

    simd_pack(intrinsic_type value) : value(value) {
        // Nothing else to init
    }

    ETL_STRONG_INLINE(value_type) operator[](size_t i) const noexcept {
        return reinterpret_cast<const value_type*>(&value)[i];
    }
};

} // end of namespace etl

#if defined __GNUC__ && __GNUC__>=6
#pragma GCC diagnostic ignored "-Wignored-attributes"
#endif

//Include al the vector implementation
#include "etl/avx512_vectorization.hpp"
#include "etl/avx_vectorization.hpp"
#include "etl/sse_vectorization.hpp"
#include "etl/no_vectorization.hpp"

#if defined __GNUC__ && __GNUC__>=6
#pragma GCC diagnostic pop
#endif

namespace etl {

template <vector_mode_t V>
struct get_intrinsic_traits {
    template <typename T>
    using type = no_intrinsic_traits<T>;
};

template <vector_mode_t V>
struct get_vector_impl {
    using type = no_vec; 
};

#ifdef __AVX512F__

template <>
struct get_intrinsic_traits<vector_mode_t::AVX512> {
    template <typename T>
    using type = avx512_intrinsic_traits<T>;
};

template <>
struct get_vector_impl<vector_mode_t::AVX512> {
    using type = avx512_vec; 
};

#endif

#ifdef __AVX__

template <>
struct get_intrinsic_traits<vector_mode_t::AVX> {
    template <typename T>
    using type = avx_intrinsic_traits<T>;
};

template <>
struct get_vector_impl<vector_mode_t::AVX> {
    using type = avx_vec; 
};

#endif

#ifdef __SSE3__

template <>
struct get_intrinsic_traits<vector_mode_t::SSE3> {
    template <typename T>
    using type = sse_intrinsic_traits<T>;
};

template <>
struct get_vector_impl<vector_mode_t::SSE3> {
    using type = sse_vec; 
};

#endif

#ifdef ETL_VECTORIZE_EXPR

#ifdef __AVX512F__

using default_vec = avx512_vec;

template <typename T>
using default_intrinsic_traits = avx512_intrinsic_traits<T>;

#elif defined(__AVX__)

using default_vec = avx_vec;

template <typename T>
using default_intrinsic_traits = avx_intrinsic_traits<T>;

#elif defined(__SSE3__)

using default_vec = sse_vec;

template <typename T>
using default_intrinsic_traits = sse_intrinsic_traits<T>;

#else

using default_vec = no_vec;

template <typename T>
using default_intrinsic_traits = no_intrinsic_traits<T>;

#endif //defined(__SSE__)

#else //ETL_VECTORIZE_EXPR

using default_vec = no_vec;

template <typename T>
using default_intrinsic_traits = no_intrinsic_traits<T>;

#endif //ETL_VECTORIZE_EXPR

template <typename T>
using default_intrinsic_type = typename default_intrinsic_traits<T>::intrinsic_type;

} //end of namespace etl