kcenon::container::simd::simd_processor Class Reference

SIMD processor for vectorized operations on container values. More...

#include <simd_processor.h>

Collaboration diagram for kcenon::container::simd::simd_processor:

Static Public Member Functions
static float	sum_floats (const std::vector< ValueVariant > &values)
	Sum all float values in a container using SIMD.
static double	sum_doubles (const std::vector< ValueVariant > &values)
	Sum all double values in a container using SIMD.
static std::optional< float >	min_float (const std::vector< ValueVariant > &values)
	Find minimum float value using SIMD.
static std::optional< float >	max_float (const std::vector< ValueVariant > &values)
	Find maximum float value using SIMD.
template<typename T >
static std::optional< double >	average (const std::vector< ValueVariant > &values)
	Compute average of numeric values.
static std::vector< size_t >	find_equal_floats (const std::vector< ValueVariant > &values, float target)
	Vectorized comparison - find all values equal to target.
static std::vector< size_t >	find_string_pattern (const std::vector< ValueVariant > &values, std::string_view pattern)
	Vectorized string search using SIMD.
template<typename T , typename Func >
static void	transform_numeric (std::vector< ValueVariant > &values, Func &&func)
	Transform all numeric values by applying a function.
static std::optional< float >	dot_product_floats (const std::vector< ValueVariant > &a, const std::vector< ValueVariant > &b)
	Parallel dot product of two float arrays.
static void	fast_copy (const void *src, void *dst, size_t size)
	Fast memory copy using SIMD.
static bool	fast_compare (const void *a, const void *b, size_t size)
	Fast memory comparison using SIMD.
static std::vector< std::vector< uint8_t > >	parallel_serialize (const std::vector< ValueVariant > &values)
	Serialize multiple values in parallel.
static uint64_t	simd_hash (const void *data, size_t size)
	Compute hash of data using SIMD.

Static Private Member Functions
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)

Detailed Description

SIMD processor for vectorized operations on container values.

Definition at line 100 of file simd_processor.h.

Member Function Documentation

average()

template<typename T >

static std::optional< double > kcenon::container::simd::simd_processor::average ( const std::vector< ValueVariant > & values )

static

Compute average of numeric values.

dot_product_floats()

static std::optional< float > kcenon::container::simd::simd_processor::dot_product_floats ( const std::vector< ValueVariant > & a, const std::vector< ValueVariant > & b )

static

Parallel dot product of two float arrays.

fast_compare()

bool kcenon::container::simd::simd_processor::fast_compare ( const void * a, const void * b, size_t size )

static

Fast memory comparison using SIMD.

Definition at line 524 of file simd_processor.cpp.

    {
        return std::memcmp(a, b, size) == 0;
    }

fast_copy()

void kcenon::container::simd::simd_processor::fast_copy ( const void * src, void * dst, size_t size )

static

Fast memory copy using SIMD.

Definition at line 518 of file simd_processor.cpp.

    {
        // Use standard memcpy which is often optimized with SIMD
        std::memcpy(dst, src, size);
    }

find_equal_floats()

std::vector< size_t > kcenon::container::simd::simd_processor::find_equal_floats ( const std::vector< ValueVariant > & values, float target )

static

Vectorized comparison - find all values equal to target.

Definition at line 502 of file simd_processor.cpp.

    {
        std::vector<size_t> indices;
        
        for (size_t i = 0; i < values.size(); ++i) {
            if (auto* f = std::get_if<float>(&values[i])) {
                if (*f == target) {
                    indices.push_back(i);
                }
            }
        }
        
        return indices;
    }

find_string_pattern()

static std::vector< size_t > kcenon::container::simd::simd_processor::find_string_pattern ( const std::vector< ValueVariant > & values, std::string_view pattern )

static

Vectorized string search using SIMD.

max_float()

std::optional< float > kcenon::container::simd::simd_processor::max_float ( const std::vector< ValueVariant > & values )

static

Find maximum float value using SIMD.

Definition at line 476 of file simd_processor.cpp.

    {
        std::vector<float> floats;
        floats.reserve(values.size());
        
        for (const auto& val : values) {
            if (auto* f = std::get_if<float>(&val)) {
                floats.push_back(*f);
            }
        }
        
        if (floats.empty()) return std::nullopt;
 
        #if defined(HAS_AVX512)
            return max_float_avx512(floats.data(), floats.size());
        #elif defined(HAS_AVX2)
            return max_float_avx2(floats.data(), floats.size());
        #elif defined(HAS_X86_SIMD) && (defined(HAS_SSE2) || defined(HAS_SSE42))
            return max_float_sse(floats.data(), floats.size());
        #elif defined(HAS_ARM_NEON)
            return max_float_neon(floats.data(), floats.size());
        #else
            return max_float_scalar(floats.data(), floats.size());
        #endif
    }

References max_float_scalar().

Here is the call graph for this function:

max_float_scalar()

float kcenon::container::simd::simd_processor::max_float_scalar ( const float * data, size_t count )

staticprivate

Definition at line 43 of file simd_processor.cpp.

    {
        if (count == 0) return std::numeric_limits<float>::lowest();
        
        float max_val = data[0];
        for (size_t i = 1; i < count; ++i) {
            if (data[i] > max_val) {
                max_val = data[i];
            }
        }
        return max_val;
    }

Referenced by max_float().

Here is the caller graph for this function:

min_float()

std::optional< float > kcenon::container::simd::simd_processor::min_float ( const std::vector< ValueVariant > & values )

static

Find minimum float value using SIMD.

Definition at line 450 of file simd_processor.cpp.

    {
        std::vector<float> floats;
        floats.reserve(values.size());
        
        for (const auto& val : values) {
            if (auto* f = std::get_if<float>(&val)) {
                floats.push_back(*f);
            }
        }
        
        if (floats.empty()) return std::nullopt;
 
        #if defined(HAS_AVX512)
            return min_float_avx512(floats.data(), floats.size());
        #elif defined(HAS_AVX2)
            return min_float_avx2(floats.data(), floats.size());
        #elif defined(HAS_X86_SIMD) && (defined(HAS_SSE2) || defined(HAS_SSE42))
            return min_float_sse(floats.data(), floats.size());
        #elif defined(HAS_ARM_NEON)
            return min_float_neon(floats.data(), floats.size());
        #else
            return min_float_scalar(floats.data(), floats.size());
        #endif
    }

References min_float_scalar().

Here is the call graph for this function:

min_float_scalar()

float kcenon::container::simd::simd_processor::min_float_scalar ( const float * data, size_t count )

staticprivate

Definition at line 30 of file simd_processor.cpp.

    {
        if (count == 0) return std::numeric_limits<float>::max();
        
        float min_val = data[0];
        for (size_t i = 1; i < count; ++i) {
            if (data[i] < min_val) {
                min_val = data[i];
            }
        }
        return min_val;
    }

Referenced by min_float().

Here is the caller graph for this function:

parallel_serialize()

static std::vector< std::vector< uint8_t > > kcenon::container::simd::simd_processor::parallel_serialize ( const std::vector< ValueVariant > & values )

static

Serialize multiple values in parallel.

simd_hash()

static uint64_t kcenon::container::simd::simd_processor::simd_hash ( const void * data, size_t size )

static

Compute hash of data using SIMD.

sum_doubles()

double kcenon::container::simd::simd_processor::sum_doubles ( const std::vector< ValueVariant > & values )

static

Sum all double values in a container using SIMD.

Definition at line 438 of file simd_processor.cpp.

    {
        // For now, use scalar implementation for doubles
        double sum = 0.0;
        for (const auto& val : values) {
            if (auto* d = std::get_if<double>(&val)) {
                sum += *d;
            }
        }
        return sum;
    }

sum_floats()

float kcenon::container::simd::simd_processor::sum_floats ( const std::vector< ValueVariant > & values )

static

Sum all float values in a container using SIMD.

Definition at line 411 of file simd_processor.cpp.

    {
        // Extract float values
        std::vector<float> floats;
        floats.reserve(values.size());
        
        for (const auto& val : values) {
            if (auto* f = std::get_if<float>(&val)) {
                floats.push_back(*f);
            }
        }
        
        if (floats.empty()) return 0.0f;
 
        #if defined(HAS_AVX512)
            return sum_floats_avx512(floats.data(), floats.size());
        #elif defined(HAS_AVX2)
            return sum_floats_avx2(floats.data(), floats.size());
        #elif defined(HAS_X86_SIMD) && (defined(HAS_SSE2) || defined(HAS_SSE42))
            return sum_floats_sse(floats.data(), floats.size());
        #elif defined(HAS_ARM_NEON)
            return sum_floats_neon(floats.data(), floats.size());
        #else
            return sum_floats_scalar(floats.data(), floats.size());
        #endif
    }

References sum_floats_scalar().

Here is the call graph for this function:

sum_floats_scalar()

float kcenon::container::simd::simd_processor::sum_floats_scalar ( const float * data, size_t count )

staticprivate

Definition at line 21 of file simd_processor.cpp.

    {
        float sum = 0.0f;
        for (size_t i = 0; i < count; ++i) {
            sum += data[i];
        }
        return sum;
    }

Referenced by sum_floats().

Here is the caller graph for this function:

transform_numeric()

template<typename T , typename Func >

static void kcenon::container::simd::simd_processor::transform_numeric ( std::vector< ValueVariant > & values, Func && func )

static

Transform all numeric values by applying a function.

---

The documentation for this class was generated from the following files:

• internal/simd_processor.h
• internal/simd_processor.cpp