simd_processor.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "value.h"
#include <vector>
#include <string>
#include <numeric>
#include <algorithm>
#include <cstring>
 
// Platform-specific SIMD headers
#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
    #define HAS_X86_SIMD 1
    #if defined(__AVX512F__) || defined(HAS_AVX512)
        #ifndef HAS_AVX512
            #define HAS_AVX512 1
        #endif
        #ifndef HAS_AVX2
            #define HAS_AVX2 1  // AVX-512 implies AVX2
        #endif
        #include <immintrin.h>
    #elif defined(__AVX2__) || defined(HAS_AVX2)
        #ifndef HAS_AVX2
            #define HAS_AVX2 1
        #endif
        #include <immintrin.h>
    #elif defined(__SSE4_2__) || defined(HAS_SSE42)
        #ifndef HAS_SSE42
            #define HAS_SSE42 1
        #endif
        #include <nmmintrin.h>  // SSE4.2
        #include <smmintrin.h>  // SSE4.1
        #include <tmmintrin.h>  // SSSE3
    #elif defined(__SSE2__)
        #define HAS_SSE2 1
        #include <emmintrin.h>  // SSE2
    #endif
    // Basic SSE headers for all x86
    #if defined(HAS_SSE42) || defined(HAS_SSE2)
        #include <xmmintrin.h>  // SSE
        #include <emmintrin.h>  // SSE2
        #include <pmmintrin.h>  // SSE3
    #elif defined(__SSE2__)
        #define HAS_SSE2 1
        #include <emmintrin.h>
    #endif
#elif defined(__ARM_NEON) || defined(__aarch64__)
    #define HAS_ARM_NEON 1
    #include <arm_neon.h>
#endif
 
namespace kcenon::container
{
namespace simd
{
    #if defined(HAS_AVX512) && defined(__x86_64__)
        constexpr size_t float_simd_width = 16;  // 512-bit / 32-bit
        constexpr size_t double_simd_width = 8;  // 512-bit / 64-bit
        constexpr size_t float_simd_width_512 = 16;
        constexpr size_t double_simd_width_512 = 8;
        constexpr size_t int32_simd_width_512 = 16;
        using float_simd = __m512;
        using double_simd = __m512d;
        using int32_simd = __m512i;
        using float_simd_512 = __m512;
        using double_simd_512 = __m512d;
        using int32_simd_512 = __m512i;
    #elif defined(HAS_AVX2) && defined(__x86_64__)
        constexpr size_t float_simd_width = 8;  // 256-bit / 32-bit
        constexpr size_t double_simd_width = 4; // 256-bit / 64-bit
        using float_simd = __m256;
        using double_simd = __m256d;
        using int32_simd = __m256i;
    #elif (defined(HAS_SSE42) || defined(HAS_SSE2)) && (defined(__x86_64__) || defined(__i386__))
        constexpr size_t float_simd_width = 4;  // 128-bit / 32-bit
        constexpr size_t double_simd_width = 2; // 128-bit / 64-bit
        using float_simd = __m128;
        using double_simd = __m128d;
        using int32_simd = __m128i;
    #elif defined(HAS_ARM_NEON) || defined(__ARM_NEON) || defined(__ARM_NEON__)
        constexpr size_t float_simd_width = 4;  // 128-bit / 32-bit
        constexpr size_t double_simd_width = 2; // 128-bit / 64-bit
        using float_simd = float32x4_t;
        using double_simd = float64x2_t;
        using int32_simd = int32x4_t;
    #else
        constexpr size_t float_simd_width = 1;  // No SIMD
        constexpr size_t double_simd_width = 1;
    #endif
 
    class simd_processor
    {
    public:
        static float sum_floats(const std::vector<ValueVariant>& values);
 
        static double sum_doubles(const std::vector<ValueVariant>& values);
 
        static std::optional<float> min_float(const std::vector<ValueVariant>& values);
 
        static std::optional<float> max_float(const std::vector<ValueVariant>& values);
 
        template<typename T>
        static std::optional<double> average(const std::vector<ValueVariant>& values);
 
        static std::vector<size_t> find_equal_floats(
            const std::vector<ValueVariant>& values,
            float target);
 
        static std::vector<size_t> find_string_pattern(
            const std::vector<ValueVariant>& values,
            std::string_view pattern);
 
        template<typename T, typename Func>
        static void transform_numeric(std::vector<ValueVariant>& values, Func&& func);
 
        static std::optional<float> dot_product_floats(
            const std::vector<ValueVariant>& a,
            const std::vector<ValueVariant>& b);
 
        static void fast_copy(const void* src, void* dst, size_t size);
 
        static bool fast_compare(const void* a, const void* b, size_t size);
 
        static std::vector<std::vector<uint8_t>> parallel_serialize(
            const std::vector<ValueVariant>& values);
 
        static uint64_t simd_hash(const void* data, size_t size);
 
    private:
        // Platform-specific implementations
        #if defined(HAS_AVX512)
        static float sum_floats_avx512(const float* data, size_t count);
        static float min_float_avx512(const float* data, size_t count);
        static float max_float_avx512(const float* data, size_t count);
        static double sum_doubles_avx512(const double* data, size_t count);
        #endif
 
        #if defined(HAS_AVX2)
        static float sum_floats_avx2(const float* data, size_t count);
        static float min_float_avx2(const float* data, size_t count);
        static float max_float_avx2(const float* data, size_t count);
        #endif
 
        #if defined(HAS_SSE42) || defined(HAS_SSE2)
        static float sum_floats_sse(const float* data, size_t count);
        static float min_float_sse(const float* data, size_t count);
        static float max_float_sse(const float* data, size_t count);
        #endif
 
        #if defined(HAS_ARM_NEON)
        static float sum_floats_neon(const float* data, size_t count);
        static float min_float_neon(const float* data, size_t count);
        static float max_float_neon(const float* data, size_t count);
        #endif
 
        // Scalar fallbacks
        static float sum_floats_scalar(const float* data, size_t count);
        static float min_float_scalar(const float* data, size_t count);
        static float max_float_scalar(const float* data, size_t count);
    };
 
    class simd_compressor
    {
    public:
        static std::vector<uint8_t> compress(const std::vector<uint8_t>& data);
 
        static std::vector<uint8_t> decompress(const std::vector<uint8_t>& compressed);
 
        static bool is_compressible(const std::vector<uint8_t>& data);
    };
 
    enum class simd_level {
        none = 0,
        sse2,
        sse42,
        avx2,
        avx512,
        neon
    };
 
    class simd_support
    {
    public:
        static bool has_sse2();
        static bool has_sse42();
        static bool has_avx2();
        static bool has_avx512f();   // AVX-512 Foundation
        static bool has_avx512dq();  // AVX-512 Double/Quad word
        static bool has_avx512bw();  // AVX-512 Byte/Word
        static bool has_avx512vl();  // AVX-512 Vector Length extensions
        static bool has_neon();
 
        static simd_level get_best_simd_level();
 
        static std::string get_simd_info();
 
        static size_t get_optimal_width() {
            #if defined(HAS_AVX512)
                return 16;
            #elif defined(HAS_AVX2)
                return 8;
            #elif defined(HAS_SSE42) || defined(HAS_SSE2) || defined(HAS_ARM_NEON)
                return 4;
            #else
                return 1;
            #endif
        }
    };
 
    template<typename T>
    struct simd_traits {
        static constexpr size_t width = 1;
        static constexpr bool supported = false;
    };
 
    #if defined(HAS_X86_SIMD) || defined(HAS_ARM_NEON)
    template<>
    struct simd_traits<float> {
        static constexpr size_t width = float_simd_width;
        static constexpr bool supported = true;
    };
 
    template<>
    struct simd_traits<double> {
        static constexpr size_t width = double_simd_width;
        static constexpr bool supported = true;
    };
 
    template<>
    struct simd_traits<int32_t> {
        static constexpr size_t width = float_simd_width; // Same as float
        static constexpr bool supported = true;
    };
    #endif
 
} // namespace simd
} // namespace kcenon::container