Simplify linux_auxval

Author: AntoinePrv

include/xsimd/config/xsimd_cpu_features_arm.hpp

@@ -14,9 +14,20 @@
 
 #include "./xsimd_config.hpp"
 
-#if XSIMD_WITH_LINUX_GETAUXVAL
+#if XSIMD_TARGET_ARM && XSIMD_WITH_LINUX_GETAUXVAL
+#include "../utils/bits.hpp"
 #include "./xsimd_getauxval.hpp"
+
+// HWCAP_XXX masks to use on getauxval results.
+// Header does not exists on all architectures and masks are architecture
+// specific.
+#include <asm/hwcap.h>
+
+// Port possibly missing mask. Should only be defined on Arm64.
+#if XSIMD_TARGET_ARM64 && !defined(HWCAP2_I8MM)
+#define HWCAP2_I8MM (1 << 13)
 #endif
+#endif // XSIMD_TARGET_ARM && XSIMD_WITH_LINUX_GETAUXVAL
 
 namespace xsimd
 {
@@ -27,8 +38,8 @@ namespace xsimd
      * On Linux, runtime detection uses getauxval to query the auxiliary vector.
      * On other platforms, only compile-time information is used.
      *
-     * This is well defined on all architectures. It will always return false on
-     * non-ARM architectures.
+     * This is well defined on all architectures.
+     * It will always return false on non-ARM architectures.
      */
     class arm_cpu_features
     {
@@ -38,7 +49,7 @@ namespace xsimd
         inline bool neon() const noexcept
         {
 #if XSIMD_TARGET_ARM && !XSIMD_TARGET_ARM64 && XSIMD_WITH_LINUX_GETAUXVAL
-            return hwcap().all_bits_set<linux_hwcap::aux::neon>();
+            return hwcap().has_feature(HWCAP_NEON);
 #else
             return static_cast<bool>(XSIMD_WITH_NEON);
 #endif
@@ -52,7 +63,7 @@ namespace xsimd
         inline bool sve() const noexcept
         {
 #if XSIMD_TARGET_ARM64 && XSIMD_WITH_LINUX_GETAUXVAL
-            return hwcap().all_bits_set<linux_hwcap::aux::sve>();
+            return hwcap().has_feature(HWCAP_SVE);
 #else
             return false;
 #endif
@@ -61,7 +72,7 @@ namespace xsimd
         inline bool i8mm() const noexcept
         {
 #if XSIMD_TARGET_ARM64 && XSIMD_WITH_LINUX_GETAUXVAL
-            return hwcap2().all_bits_set<linux_hwcap2::aux::i8mm>();
+            return hwcap2().has_feature(HWCAP2_I8MM);
 #else
             return false;
 #endif
@@ -79,26 +90,26 @@ namespace xsimd
 
         mutable status_bitset m_status {};
 
-        mutable xsimd::linux_hwcap m_hwcap {};
+        mutable xsimd::linux_auxval m_hwcap {};
 
-        inline xsimd::linux_hwcap const& hwcap() const noexcept
+        inline xsimd::linux_auxval const& hwcap() const noexcept
         {
             if (!m_status.bit_is_set<status::hwcap_valid>())
             {
-                m_hwcap = xsimd::linux_hwcap::read();
+                m_hwcap = xsimd::linux_auxval::read(AT_HWCAP);
                 m_status.set_bit<status::hwcap_valid>();
             }
             return m_hwcap;
         }
 
 #if XSIMD_TARGET_ARM64
-        mutable xsimd::linux_hwcap2 m_hwcap2 {};
+        mutable xsimd::linux_auxval m_hwcap2 {};
 
-        inline xsimd::linux_hwcap2 const& hwcap2() const noexcept
+        inline xsimd::linux_auxval const& hwcap2() const noexcept
         {
             if (!m_status.bit_is_set<status::hwcap2_valid>())
             {
-                m_hwcap2 = xsimd::linux_hwcap2::read();
+                m_hwcap2 = xsimd::linux_auxval::read(AT_HWCAP2);
                 m_status.set_bit<status::hwcap2_valid>();
             }
             return m_hwcap2;

include/xsimd/config/xsimd_getauxval.hpp

@@ -12,7 +12,6 @@
 #ifndef XSIMD_GETAUXVAL_HPP
 #define XSIMD_GETAUXVAL_HPP
 
-#include "../utils/bits.hpp"
 #include "./xsimd_config.hpp"
 
 #if XSIMD_WITH_LINUX_GETAUXVAL
@@ -26,96 +25,49 @@ namespace xsimd
         using linux_getauxval_t = unsigned long;
 
         inline linux_getauxval_t linux_getauxval(linux_getauxval_t type) noexcept;
-
-        /**
-         * Base class for getauxval querying.
-         */
-        template <linux_getauxval_t type, typename A>
-        class linux_auxval : private utils::uint_bitset<A, linux_getauxval_t>
-        {
-            using bitset_t = utils::uint_bitset<A, linux_getauxval_t>;
-            using bitset_t::bitset_t;
-
-        public:
-            using aux = A;
-
-            inline static linux_auxval read()
-            {
-                return linux_auxval(linux_getauxval(type));
-            }
-
-            /** Create a value which returns false to everything. */
-            constexpr linux_auxval() noexcept = default;
-
-            using bitset_t::all_bits_set;
-        };
-
-        template <typename Traits>
-        using make_auxiliary_val_t = linux_auxval<Traits::type, typename Traits::aux>;
     }
 
     /*
-     * Hardware Capabilities Register (HWCAP) for Linux.
+     * Holds the value of a Linux auxiliary vector entry (e.g. AT_HWCAP).
      *
      * On Linux systems, the kernel exposes some CPU features through the
      * auxiliary vector, which can be queried via `getauxval(AT_HWCAP)`.
-     * This utility parses such bit values.
+     * Well defined on all platforms, and will return always falsw on
+     * non-linux platforms.
+     *
+     * Usage:
+     *   auto hwcap = linux_auxval::read(AT_HWCAP);
+     *   bool neon = hwcap.has_feature(HWCAP_NEON);
      *
      * @see https://www.kernel.org/doc/Documentation/arm64/elf_hwcaps.txt
      */
-    struct linux_hwcap_traits
+    class linux_auxval
     {
-#if XSIMD_WITH_LINUX_GETAUXVAL
-        static constexpr detail::linux_getauxval_t type = AT_HWCAP;
-#else
-        static constexpr detail::linux_getauxval_t type = 0;
-#endif
+    private:
+        using getauxval_t = detail::linux_getauxval_t;
 
-        enum class aux
+    public:
+        constexpr linux_auxval() noexcept = default;
+
+        inline static linux_auxval read(getauxval_t type) noexcept
         {
-#if XSIMD_WITH_LINUX_GETAUXVAL
-#if XSIMD_TARGET_ARM64
-            /** Scalable Vector Extension. */
-            sve = 22,
-#elif XSIMD_TARGET_ARM
-            /** Neon vector extension. */
-            neon = 12,
-#endif
-#endif
-        };
-    };
+            return linux_auxval(detail::linux_getauxval(type));
+        }
 
-    using linux_hwcap = detail::make_auxiliary_val_t<linux_hwcap_traits>;
+        constexpr bool has_feature(getauxval_t feat) const noexcept
+        {
+            return (m_auxval & feat) == feat;
+        }
 
-    /*
-     * Extended Hardware Capabilities Register (HWCAP2) for Linux.
-     *
-     * On Linux systems, the kernel exposes some CPU additional features through the
-     * auxiliary vector, which can be queried via `getauxval(AT_HWCAP2)`.
-     *
-     * @see https://www.kernel.org/doc/Documentation/arm64/elf_hwcaps.txt
-     */
-    struct linux_hwcap2_traits
-    {
-#if XSIMD_WITH_LINUX_GETAUXVAL
-        static constexpr detail::linux_getauxval_t type = AT_HWCAP2;
-#else
-        static constexpr detail::linux_getauxval_t type = 0;
-#endif
+    private:
+        getauxval_t m_auxval = {};
 
-        enum class aux
+        constexpr explicit linux_auxval(getauxval_t v) noexcept
+            : m_auxval(v)
         {
-#if XSIMD_WITH_LINUX_GETAUXVAL
-#if XSIMD_TARGET_ARM64
-            /** 8 bits integer matrix multiplication. */
-            i8mm = 13,
-#endif
-#endif
-        };
+        }
     };
 
-    using linux_hwcap2 = detail::make_auxiliary_val_t<linux_hwcap2_traits>;
-
     /********************
      *  Implementation  *
      ********************/
@@ -128,7 +80,7 @@ namespace xsimd
             return getauxval(type);
         }
 #else
-        inline linux_getauxval_t linux_getauxval(linux_getauxval_t type) noexcept
+        inline linux_getauxval_t linux_getauxval(linux_getauxval_t) noexcept
         {
             return {}; // All bits set to 0
         }