builtin_simd.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <bit>
#include <type_traits>
 
#include <seqan3/utility/detail/integer_traits.hpp>
#include <seqan3/utility/simd/detail/default_simd_length.hpp>
#include <seqan3/utility/simd/simd_traits.hpp>
#include <seqan3/utility/type_traits/detail/transformation_trait_or.hpp>
 
namespace seqan3::detail
{
 
template <typename scalar_t, size_t length>
struct builtin_simd;
 
template <typename scalar_t, size_t length>
    requires (std::has_single_bit(length))
struct builtin_simd<scalar_t, length>
{
#if SEQAN3_DOXYGEN_ONLY(1) 0
    using type = scalar_t __attribute__((vector_size(sizeof(scalar_t) * length))));
    // doxygen 1.8.13 does not support c++11 attributes, thus this doxygen-only definition
#elif defined(__clang__)
    using type = scalar_t __attribute__((ext_vector_type(length)));
#else
    using type [[gnu::vector_size(sizeof(scalar_t) * length)]] = scalar_t;
#endif
};
 
template <typename builtin_simd_t>
struct builtin_simd_traits_helper : std::false_type
{};
 
template <typename builtin_simd_t>
// NOTE: gcc throws a compile time error if builtin_simd_t is a pointer of an incomplete type. To tackle this we
// short-circuit the requires with is_pointer_v. See builtin_simd_test.cpp for a test case for this.
    requires (!std::is_pointer_v<std::decay_t<builtin_simd_t>>) && requires (builtin_simd_t simd) {
                                                                       {
                                                                           simd[0]
                                                                       };
                                                                   }
struct builtin_simd_traits_helper<builtin_simd_t>
{
    using scalar_type = std::remove_reference_t<decltype(std::declval<builtin_simd_t>()[0])>;
    static constexpr auto length = sizeof(builtin_simd_t) / sizeof(scalar_type);
 
    static constexpr bool value =
        std::has_single_bit(length)
        && std::is_same_v<builtin_simd_t, transformation_trait_or_t<builtin_simd<scalar_type, length>, void>>;
};
 
template <typename builtin_simd_t>
struct is_builtin_simd : std::bool_constant<builtin_simd_traits_helper<builtin_simd_t>::value>
{};
 
template <typename builtin_simd_t>
constexpr bool is_builtin_simd_v = is_builtin_simd<builtin_simd_t>::value;
 
template <>
inline constexpr auto default_simd_max_length<builtin_simd> = []()
{
#if defined(__AVX512F__)
    return min_viable_uint_v<64u>;
#elif defined(__AVX2__)
    return min_viable_uint_v<32u>;
#elif defined(__SSE4_1__) && defined(__SSE4_2__)
    return min_viable_uint_v<16u>;
#else
    return min_viable_uint_v<0u>;
#endif
}();
 
template <typename builtin_simd_t>
struct is_native_builtin_simd :
    std::bool_constant<(default_simd_max_length<builtin_simd> != 0)
                       && ((builtin_simd_traits_helper<builtin_simd_t>::length
                            * sizeof(typename builtin_simd_traits_helper<builtin_simd_t>::scalar_type))
                           >= 16)
                       && ((builtin_simd_traits_helper<builtin_simd_t>::length
                            * sizeof(typename builtin_simd_traits_helper<builtin_simd_t>::scalar_type))
                           <= 64)>
{};
 
template <typename builtin_simd_t>
constexpr bool is_native_builtin_simd_v = is_native_builtin_simd<builtin_simd_t>::value;
 
} // namespace seqan3::detail
 
namespace seqan3
{
 
inline namespace simd
{
 
template <typename builtin_simd_t>
// \cond
    requires detail::is_builtin_simd<builtin_simd_t>::value
// \endcond
struct simd_traits<builtin_simd_t>
{
    using scalar_type = typename detail::builtin_simd_traits_helper<builtin_simd_t>::scalar_type;
    static constexpr auto length = detail::builtin_simd_traits_helper<builtin_simd_t>::length;
    static constexpr auto max_length = length == 1u ? length : sizeof(scalar_type) * length;
 
    static_assert(std::is_integral_v<scalar_type>, "For now we assume that builtin simd can only be integers");
    using mask_type = decltype(std::declval<builtin_simd_t>() == std::declval<builtin_simd_t>());
    using swizzle_type = typename detail::builtin_simd<uint8_t, max_length>::type;
 
    template <typename new_scalar_type>
    // \cond
        requires (sizeof(scalar_type) == sizeof(new_scalar_type))
    // \endcond
    using rebind = typename detail::builtin_simd<new_scalar_type, length>::type;
};
 
} // namespace simd
 
} // namespace seqan3