Properly check if subleaf is available

Author: AntoinePrv

include/xsimd/config/xsimd_cpu_features_x86.hpp

@@ -94,9 +94,13 @@ namespace xsimd
             constexpr x86_cpuid_regs() noexcept = default;
 
             using eax_bitset::all_bits_set;
+            using eax_bitset::get_range;
             using ebx_bitset::all_bits_set;
+            using ebx_bitset::get_range;
             using ecx_bitset::all_bits_set;
+            using ecx_bitset::get_range;
             using edx_bitset::all_bits_set;
+            using edx_bitset::get_range;
         };
 
         template <typename T>
@@ -239,6 +243,10 @@ namespace xsimd
 
         enum class eax
         {
+            /* Start bit for the encoding of the highest subleaf available. */
+            highest_subleaf_start = 0,
+            /* End bit for the encoding of the highest subleaf available. */
+            highest_subleaf_end = 32,
         };
         enum class ebx
         {
@@ -645,7 +653,25 @@ namespace xsimd
 
         inline x86_cpuid_leaf7sub1 const& leaf7sub1() const
         {
-            return safe_get_leaf<status::leaf7sub1_valid>(m_leaf7sub1);
+            // Check if already initialized
+            if (m_status.bit_is_set<status::leaf7sub1_valid>())
+            {
+                return m_leaf7sub1;
+            }
+
+            // Check if safe to call CPUID with this value as subleaf.
+            constexpr auto start = x86_cpuid_leaf7::eax::highest_subleaf_start;
+            constexpr auto end = x86_cpuid_leaf7::eax::highest_subleaf_end;
+            const auto highest_subleaf7 = leaf7().get_range<start, end>();
+            if (x86_cpuid_leaf7sub1::subleaf <= highest_subleaf7)
+            {
+                m_leaf7sub1 = x86_cpuid_leaf7sub1::read();
+            }
+
+            // Mark as valid in all cases, including if it was not read.
+            // In this case it will be filled with zeros (all false).
+            m_status.set_bit<status::leaf7sub1_valid>();
+            return m_leaf7sub1;
         }
 
         inline x86_cpuid_leaf80000001 const& leaf80000001() const

include/xsimd/utils/bits.hpp

@@ -46,6 +46,21 @@ namespace xsimd
             return value | mask;
         }
 
+        /**
+         * Return a mask with the `width` lowest bits set.
+         */
+        template <typename I>
+        constexpr I make_low_mask(I width) noexcept
+        {
+            assert(width >= 0);
+            assert(width <= static_cast<I>(8 * sizeof(I)));
+            if (width == static_cast<I>(8 * sizeof(I)))
+            {
+                return ~I { 0 };
+            }
+            return (I { 1 } << width) - I { 1 };
+        }
+
         /* A bitset over an unsigned integer type, indexed by an enum key type. */
         template <typename K, typename U>
         struct uint_bitset
@@ -82,6 +97,17 @@ namespace xsimd
                 m_bitset = utils::set_bit<static_cast<storage_type>(bit)>(m_bitset);
             }
 
+            /* Extract the bits in [start, end[, shifted down to start at bit 0. */
+            template <key_type start, key_type end>
+            constexpr storage_type get_range() const noexcept
+            {
+                constexpr storage_type start_bit = static_cast<storage_type>(start);
+                constexpr storage_type end_bit = static_cast<storage_type>(end);
+                constexpr storage_type width = end_bit - start_bit;
+                constexpr storage_type mask = make_low_mask<storage_type>(width);
+                return (m_bitset >> start_bit) & mask;
+            }
+
         private:
             storage_type m_bitset = { 0 };
         };