Add single shift optimization

Author: AntoinePrv

include/xsimd/arch/utils/shifts.hpp

@@ -38,9 +38,26 @@ namespace xsimd
             template <typename I>
             constexpr I lsb_mask(I bit_index)
             {
+                if (bit_index == 8 * sizeof(I))
+                {
+                    return ~I { 0 };
+                }
                 return static_cast<I>((I { 1 } << bit_index) - I { 1 });
             }
 
+            template <class T, class A, T... Vs>
+            constexpr bool all_equals(batch_constant<T, A, Vs...> c)
+            {
+                static_assert(sizeof...(Vs) > 0);
+
+                bool out = true;
+                for (std::size_t k = 0; k < sizeof...(Vs); ++k)
+                {
+                    out &= c.get(k) == c.get(0);
+                }
+                return out;
+            }
+
             template <class T, class T2, class A, T... Vs>
             XSIMD_INLINE batch<T, A> bitwise_lshift_as_twice_larger(
                 batch<T, A> const& self, batch_constant<T, A, Vs...>) noexcept

include/xsimd/arch/xsimd_avx2.hpp

@@ -337,9 +337,14 @@ namespace xsimd
         // Missing implementations are dispacthed to the `batch` overload in xsimd_api.
         template <class T, class A, T... Vs, detail::enable_sized_integral_t<T, 2> = 0>
         XSIMD_INLINE batch<T, A> bitwise_lshift(
-            batch<T, A> const& self, batch_constant<T, A, Vs...>, requires_arch<avx2>) noexcept
+            batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept
         {
             using uint_t = typename std::make_unsigned<T>::type;
+
+            XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
+            {
+                return bitwise_lshift<shifts.get(0), A>(self, req);
+            }
             return bitwise_cast<T>(
                 utils::bitwise_lshift_as_twice_larger<uint_t, uint32_t>(
                     bitwise_cast<uint_t>(self),
@@ -348,9 +353,14 @@ namespace xsimd
 
         template <class T, class A, T... Vs, detail::enable_sized_integral_t<T, 1> = 0>
         XSIMD_INLINE batch<T, A> bitwise_lshift(
-            batch<T, A> const& self, batch_constant<T, A, Vs...>, requires_arch<avx2>) noexcept
+            batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept
         {
             using uint_t = typename std::make_unsigned<T>::type;
+
+            XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
+            {
+                return bitwise_lshift<shifts.get(0), A>(self, req);
+            }
             return bitwise_cast<T>(
                 utils::bitwise_lshift_as_twice_larger<uint_t, uint16_t>(
                     bitwise_cast<uint_t>(self),

include/xsimd/arch/xsimd_sse2.hpp

@@ -328,18 +328,27 @@ namespace xsimd
         }
 
         // bitwise_lshift multiple (constant)
+        // Missing implementations are dispacthed to the `batch` overload in xsimd_api.
         template <class A, uint16_t... Vs>
         XSIMD_INLINE batch<uint16_t, A> bitwise_lshift(
-            batch<uint16_t, A> const& self, batch_constant<uint16_t, A, Vs...>, requires_arch<sse2>) noexcept
+            batch<uint16_t, A> const& self, batch_constant<uint16_t, A, Vs...> shifts, requires_arch<sse2> req) noexcept
         {
+            XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
+            {
+                return bitwise_lshift<shifts.get(0), A>(self, req);
+            }
             constexpr auto mults = batch_constant<uint16_t, A, static_cast<uint16_t>(1u << Vs)...>();
             return _mm_mullo_epi16(self, mults.as_batch());
         }
 
         template <class A, uint8_t... Vs>
         XSIMD_INLINE batch<uint8_t, A> bitwise_lshift(
-            batch<uint8_t, A> const& self, batch_constant<uint8_t, A, Vs...> shifts, requires_arch<sse2>) noexcept
+            batch<uint8_t, A> const& self, batch_constant<uint8_t, A, Vs...> shifts, requires_arch<sse2> req) noexcept
         {
+            XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
+            {
+                return bitwise_lshift<shifts.get(0), A>(self, req);
+            }
             return utils::bitwise_lshift_as_twice_larger<uint8_t, uint16_t>(self, shifts);
         }