builtin_simd.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/std/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 <>
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;
};
 
} // inline namespace simd
 
} // namespace seqan3