xsimd/types/xsimd_emulated_register.hpp

0001 /***************************************************************************
0002  * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
0003  * Martin Renou                                                             *
0004  * Copyright (c) QuantStack                                                 *
0005  * Copyright (c) Serge Guelton                                              *
0006  *                                                                          *
0007  * Distributed under the terms of the BSD 3-Clause License.                 *
0008  *                                                                          *
0009  * The full license is in the file LICENSE, distributed with this software. *
0010  ****************************************************************************/
0011
0012 #ifndef XSIMD_EMULATED_REGISTER_HPP
0013 #define XSIMD_EMULATED_REGISTER_HPP
0014
0015 #include "./xsimd_generic_arch.hpp"
0016 #include "./xsimd_register.hpp"
0017
0018 namespace xsimd
0019 {
0020     /**
0021      * @ingroup architectures
0022      *
0023      * emulated instructions
0024      */
0025     template <size_t N>
0026     struct emulated : generic
0027     {
0028         static constexpr bool supported() noexcept { return true; }
0029         static constexpr bool available() noexcept { return true; }
0030         static constexpr bool requires_alignment() noexcept { return false; }
0031         static constexpr std::size_t alignment() noexcept { return 8; }
0032         static constexpr char const* name() noexcept { return "emulated"; }
0033     };
0034
0035     namespace types
0036     {
0037         template <size_t N>
0038         struct simd_emulated_bool_register
0039         {
0040             using register_type = std::array<bool, N>;
0041             register_type data;
0042             simd_emulated_bool_register() = default;
0043             simd_emulated_bool_register(register_type r) { data = r; }
0044             operator register_type() const noexcept { return data; }
0045         };
0046         template <typename T, size_t N>
0047         struct get_bool_simd_register<T, emulated<N>>
0048         {
0049             using type = simd_emulated_bool_register<N / (8 * sizeof(T))>;
0050         };
0051
0052         template <typename T, size_t N>
0053         struct simd_register<T, emulated<N>>
0054         {
0055             static_assert(N % (8 * sizeof(T)) == 0, "bit width must be a multiple of scalar width");
0056             using register_type = std::array<T, N / (8 * sizeof(T))>;
0057             register_type data;
0058             XSIMD_INLINE operator register_type() const noexcept
0059             {
0060                 return data;
0061             }
0062         };
0063         template <typename T, size_t N>
0064         struct has_simd_register<T, emulated<N>> : std::is_scalar<T>
0065         {
0066         };
0067         template <typename T, size_t N>
0068         struct has_simd_register<std::complex<T>, emulated<N>> : std::true_type
0069         {
0070         };
0071 #ifdef XSIMD_ENABLE_XTL_COMPLEX
0072         template <typename T, bool i3ec, size_t N>
0073         struct has_simd_register<xtl::complex<T, T, i3ec>, emulated<N>> : std::true_type
0074         {
0075         };
0076 #endif
0077     }
0078 }
0079
0080 #endif