kcenon::monitoring::simd_aggregator Class Reference

SIMD-accelerated statistical aggregator. More...

#include <simd_aggregator.h>

Collaboration diagram for kcenon::monitoring::simd_aggregator:

Public Member Functions
	simd_aggregator ()
	Default constructor with default configuration.
	simd_aggregator (const simd_config &config)
	Construct with configuration.
common::Result< double >	sum (const std::vector< double > &data)
	Calculate sum of elements.
common::Result< double >	mean (const std::vector< double > &data)
	Calculate mean of elements.
common::Result< double >	min (const std::vector< double > &data)
	Find minimum value.
common::Result< double >	max (const std::vector< double > &data)
	Find maximum value.
common::Result< double >	variance (const std::vector< double > &data)
	Calculate variance of elements.
common::Result< statistical_summary >	compute_summary (const std::vector< double > &data)
	Compute full statistical summary.
const simd_capabilities &	get_capabilities () const
	Get SIMD capabilities.
common::Result< bool >	test_simd ()
	Self-test SIMD functionality.
const simd_aggregator_statistics &	get_statistics () const
	Get aggregator statistics.
void	reset_statistics ()
	Reset statistics.

Private Member Functions
bool	should_use_simd (size_t data_size) const
double	sum_scalar (const std::vector< double > &data) const
double	sum_simd (const std::vector< double > &data) const
double	min_scalar (const std::vector< double > &data) const
double	min_simd (const std::vector< double > &data) const
double	max_scalar (const std::vector< double > &data) const
double	max_simd (const std::vector< double > &data) const

Private Attributes
simd_config	config_
simd_capabilities	capabilities_
simd_aggregator_statistics	stats_

Detailed Description

SIMD-accelerated statistical aggregator.

This class provides high-performance statistical operations using SIMD (Single Instruction Multiple Data) instructions when available. Falls back to scalar operations when SIMD is not available or disabled.

Definition at line 189 of file simd_aggregator.h.

Constructor & Destructor Documentation

simd_aggregator() [1/2]

kcenon::monitoring::simd_aggregator::simd_aggregator ( )

inline

Default constructor with default configuration.

Definition at line 194 of file simd_aggregator.h.

: simd_aggregator(simd_config{}) {}

simd_aggregator() [2/2]

kcenon::monitoring::simd_aggregator::simd_aggregator ( const simd_config & config )

inlineexplicit

Construct with configuration.

Parameters

config

Aggregator configuration

Definition at line 200 of file simd_aggregator.h.

        : config_(config)
        , capabilities_(simd_capabilities::detect()) {}

Member Function Documentation

compute_summary()

common::Result< statistical_summary > kcenon::monitoring::simd_aggregator::compute_summary ( const std::vector< double > & data )

inline

Compute full statistical summary.

Parameters

data	Input data vector

Returns

common::Result<statistical_summary> containing statistics

Definition at line 335 of file simd_aggregator.h.

                                                                                     {
        if (data.empty()) {
            return common::Result<statistical_summary>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute summary of empty data").to_common_error());
        }
 
        statistical_summary summary;
        summary.count = data.size();
 
        // Compute sum
        auto sum_result = sum(data);
        if (sum_result.is_err()) {
            return common::Result<statistical_summary>::err(error_info(monitoring_error_code::operation_failed, "Failed to compute sum").to_common_error());
        }
        summary.sum = sum_result.value();
        summary.mean = summary.sum / static_cast<double>(summary.count);
 
        // Compute min/max
        auto min_result = min(data);
        auto max_result = max(data);
 
        if (min_result.is_err() || max_result.is_err()) {
            return common::Result<statistical_summary>::err(error_info(monitoring_error_code::operation_failed, "Failed to compute min/max").to_common_error());
        }
 
        summary.min_val = min_result.value();
        summary.max_val = max_result.value();
 
        // Compute variance
        if (summary.count > 1) {
            auto var_result = variance(data);
            if (var_result.is_ok()) {
                summary.variance = var_result.value();
                summary.std_dev = std::sqrt(summary.variance);
            }
        }
 
        return common::ok(summary);
    }

References kcenon::monitoring::statistical_summary::count, kcenon::monitoring::invalid_argument, max(), min(), kcenon::monitoring::operation_failed, sum(), kcenon::monitoring::summary, and variance().

Referenced by TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

get_capabilities()

const simd_capabilities & kcenon::monitoring::simd_aggregator::get_capabilities ( ) const

inline

Get SIMD capabilities.

Returns

Reference to detected capabilities

Definition at line 378 of file simd_aggregator.h.

                                                      {
        return capabilities_;
    }

References capabilities_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

get_statistics()

const simd_aggregator_statistics & kcenon::monitoring::simd_aggregator::get_statistics ( ) const

inline

Get aggregator statistics.

Returns

Reference to statistics

Definition at line 430 of file simd_aggregator.h.

                                                             {
        return stats_;
    }

References stats_.

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

max()

common::Result< double > kcenon::monitoring::simd_aggregator::max ( const std::vector< double > & data )

inline

Find maximum value.

Parameters

data	Input data vector

Returns

common::Result<double> containing maximum

Definition at line 279 of file simd_aggregator.h.

                                                            {
        if (data.empty()) {
            return common::Result<double>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute max of empty data").to_common_error());
        }
 
        stats_.total_operations++;
        stats_.total_elements_processed += data.size();
 
        double result = 0.0;
 
        if (should_use_simd(data.size())) {
            result = max_simd(data);
            stats_.simd_operations++;
        } else {
            result = max_scalar(data);
            stats_.scalar_operations++;
        }
 
        return common::ok(result);
    }

References kcenon::monitoring::invalid_argument, max_scalar(), max_simd(), kcenon::monitoring::simd_aggregator_statistics::scalar_operations, should_use_simd(), kcenon::monitoring::simd_aggregator_statistics::simd_operations, stats_, kcenon::monitoring::simd_aggregator_statistics::total_elements_processed, and kcenon::monitoring::simd_aggregator_statistics::total_operations.

Referenced by compute_summary(), TEST_F(), TEST_F(), and test_simd().

Here is the call graph for this function:

Here is the caller graph for this function:

max_scalar()

double kcenon::monitoring::simd_aggregator::max_scalar ( const std::vector< double > & data ) const

inlineprivate

Definition at line 596 of file simd_aggregator.h.

                                                           {
        return *std::max_element(data.begin(), data.end());
    }

Referenced by max(), and max_simd().

Here is the caller graph for this function:

max_simd()

double kcenon::monitoring::simd_aggregator::max_simd ( const std::vector< double > & data ) const

inlineprivate

Definition at line 600 of file simd_aggregator.h.

                                                         {
#if defined(SIMD_AVX2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)) && defined(__AVX2__)
        const size_t simd_width = 4;
        size_t simd_count = data.size() / simd_width;
 
        __m256d max_vec = _mm256_set1_pd(std::numeric_limits<double>::lowest());
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m256d vec = _mm256_loadu_pd(&data[i * simd_width]);
            max_vec = _mm256_max_pd(max_vec, vec);
        }
 
        alignas(32) double temp[4];
        _mm256_storeu_pd(temp, max_vec);
        double result = std::max({temp[0], temp[1], temp[2], temp[3]});
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::max(result, data[i]);
        }
 
        return result;
#elif defined(SIMD_SSE2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86))
        const size_t simd_width = 2;
        size_t simd_count = data.size() / simd_width;
 
        __m128d max_vec = _mm_set1_pd(std::numeric_limits<double>::lowest());
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m128d vec = _mm_loadu_pd(&data[i * simd_width]);
            max_vec = _mm_max_pd(max_vec, vec);
        }
 
        alignas(16) double temp[2];
        _mm_storeu_pd(temp, max_vec);
        double result = std::max(temp[0], temp[1]);
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::max(result, data[i]);
        }
 
        return result;
#elif defined(SIMD_NEON_AVAILABLE) && (defined(__aarch64__) || defined(_M_ARM64))
        const size_t simd_width = 2;
        size_t simd_count = data.size() / simd_width;
 
        float64x2_t max_vec = vdupq_n_f64(std::numeric_limits<double>::lowest());
 
        for (size_t i = 0; i < simd_count; ++i) {
            float64x2_t vec = vld1q_f64(&data[i * simd_width]);
            max_vec = vmaxq_f64(max_vec, vec);
        }
 
        double result = std::max(vgetq_lane_f64(max_vec, 0), vgetq_lane_f64(max_vec, 1));
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::max(result, data[i]);
        }
 
        return result;
#else
        return max_scalar(data);
#endif
    }

References max_scalar().

Referenced by max().

Here is the call graph for this function:

Here is the caller graph for this function:

mean()

common::Result< double > kcenon::monitoring::simd_aggregator::mean ( const std::vector< double > & data )

inline

Calculate mean of elements.

Parameters

data	Input data vector

Returns

common::Result<double> containing mean

Definition at line 235 of file simd_aggregator.h.

                                                             {
        if (data.empty()) {
            return common::Result<double>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute mean of empty data").to_common_error());
        }
 
        auto sum_result = sum(data);
        if (sum_result.is_err()) {
            return sum_result;
        }
 
        return common::ok(sum_result.value() / static_cast<double>(data.size()));
    }

References kcenon::monitoring::invalid_argument, and sum().

Referenced by TEST_F(), TEST_F(), TEST_F(), test_simd(), and variance().

Here is the call graph for this function:

Here is the caller graph for this function:

min()

common::Result< double > kcenon::monitoring::simd_aggregator::min ( const std::vector< double > & data )

inline

Find minimum value.

Parameters

data	Input data vector

Returns

common::Result<double> containing minimum

Definition at line 253 of file simd_aggregator.h.

                                                            {
        if (data.empty()) {
            return common::Result<double>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute min of empty data").to_common_error());
        }
 
        stats_.total_operations++;
        stats_.total_elements_processed += data.size();
 
        double result = 0.0;
 
        if (should_use_simd(data.size())) {
            result = min_simd(data);
            stats_.simd_operations++;
        } else {
            result = min_scalar(data);
            stats_.scalar_operations++;
        }
 
        return common::ok(result);
    }

References kcenon::monitoring::invalid_argument, min_scalar(), min_simd(), kcenon::monitoring::simd_aggregator_statistics::scalar_operations, should_use_simd(), kcenon::monitoring::simd_aggregator_statistics::simd_operations, stats_, kcenon::monitoring::simd_aggregator_statistics::total_elements_processed, and kcenon::monitoring::simd_aggregator_statistics::total_operations.

Referenced by compute_summary(), TEST_F(), TEST_F(), and test_simd().

Here is the call graph for this function:

Here is the caller graph for this function:

min_scalar()

double kcenon::monitoring::simd_aggregator::min_scalar ( const std::vector< double > & data ) const

inlineprivate

Definition at line 528 of file simd_aggregator.h.

                                                           {
        return *std::min_element(data.begin(), data.end());
    }

Referenced by min(), and min_simd().

Here is the caller graph for this function:

min_simd()

double kcenon::monitoring::simd_aggregator::min_simd ( const std::vector< double > & data ) const

inlineprivate

Definition at line 532 of file simd_aggregator.h.

                                                         {
#if defined(SIMD_AVX2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)) && defined(__AVX2__)
        const size_t simd_width = 4;
        size_t simd_count = data.size() / simd_width;
 
        __m256d min_vec = _mm256_set1_pd(std::numeric_limits<double>::max());
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m256d vec = _mm256_loadu_pd(&data[i * simd_width]);
            min_vec = _mm256_min_pd(min_vec, vec);
        }
 
        alignas(32) double temp[4];
        _mm256_storeu_pd(temp, min_vec);
        double result = std::min({temp[0], temp[1], temp[2], temp[3]});
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::min(result, data[i]);
        }
 
        return result;
#elif defined(SIMD_SSE2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86))
        const size_t simd_width = 2;
        size_t simd_count = data.size() / simd_width;
 
        __m128d min_vec = _mm_set1_pd(std::numeric_limits<double>::max());
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m128d vec = _mm_loadu_pd(&data[i * simd_width]);
            min_vec = _mm_min_pd(min_vec, vec);
        }
 
        alignas(16) double temp[2];
        _mm_storeu_pd(temp, min_vec);
        double result = std::min(temp[0], temp[1]);
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::min(result, data[i]);
        }
 
        return result;
#elif defined(SIMD_NEON_AVAILABLE) && (defined(__aarch64__) || defined(_M_ARM64))
        const size_t simd_width = 2;
        size_t simd_count = data.size() / simd_width;
 
        float64x2_t min_vec = vdupq_n_f64(std::numeric_limits<double>::max());
 
        for (size_t i = 0; i < simd_count; ++i) {
            float64x2_t vec = vld1q_f64(&data[i * simd_width]);
            min_vec = vminq_f64(min_vec, vec);
        }
 
        double result = std::min(vgetq_lane_f64(min_vec, 0), vgetq_lane_f64(min_vec, 1));
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result = std::min(result, data[i]);
        }
 
        return result;
#else
        return min_scalar(data);
#endif
    }

References min_scalar().

Referenced by min().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_statistics()

void kcenon::monitoring::simd_aggregator::reset_statistics ( )

inline

Reset statistics.

Definition at line 437 of file simd_aggregator.h.

                            {
        stats_.reset();
    }

References kcenon::monitoring::simd_aggregator_statistics::reset(), and stats_.

Here is the call graph for this function:

should_use_simd()

bool kcenon::monitoring::simd_aggregator::should_use_simd ( size_t data_size ) const

inlineprivate

Definition at line 442 of file simd_aggregator.h.

                                                 {
        if (!config_.enable_simd) {
            return false;
        }
 
        // Use SIMD only for sufficiently large datasets
        if (data_size < config_.vector_size * 2) {
            return false;
        }
 
        // Check if any SIMD is available
        return capabilities_.avx2_available ||
               capabilities_.sse2_available ||
               capabilities_.neon_available;
    }

References kcenon::monitoring::simd_capabilities::avx2_available, capabilities_, config_, kcenon::monitoring::simd_config::enable_simd, kcenon::monitoring::simd_capabilities::neon_available, kcenon::monitoring::simd_capabilities::sse2_available, and kcenon::monitoring::simd_config::vector_size.

Referenced by max(), min(), and sum().

Here is the caller graph for this function:

sum()

common::Result< double > kcenon::monitoring::simd_aggregator::sum ( const std::vector< double > & data )

inline

Calculate sum of elements.

Parameters

data	Input data vector

Returns

common::Result<double> containing sum

Definition at line 209 of file simd_aggregator.h.

                                                            {
        if (data.empty()) {
            return common::Result<double>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute sum of empty data").to_common_error());
        }
 
        stats_.total_operations++;
        stats_.total_elements_processed += data.size();
 
        double result = 0.0;
 
        if (should_use_simd(data.size())) {
            result = sum_simd(data);
            stats_.simd_operations++;
        } else {
            result = sum_scalar(data);
            stats_.scalar_operations++;
        }
 
        return common::ok(result);
    }

References kcenon::monitoring::invalid_argument, kcenon::monitoring::simd_aggregator_statistics::scalar_operations, should_use_simd(), kcenon::monitoring::simd_aggregator_statistics::simd_operations, stats_, sum_scalar(), sum_simd(), kcenon::monitoring::simd_aggregator_statistics::total_elements_processed, and kcenon::monitoring::simd_aggregator_statistics::total_operations.

Referenced by compute_summary(), mean(), TEST_F(), TEST_F(), TEST_F(), and test_simd().

Here is the call graph for this function:

Here is the caller graph for this function:

sum_scalar()

double kcenon::monitoring::simd_aggregator::sum_scalar ( const std::vector< double > & data ) const

inlineprivate

Definition at line 458 of file simd_aggregator.h.

                                                           {
        return std::accumulate(data.begin(), data.end(), 0.0);
    }

Referenced by sum(), and sum_simd().

Here is the caller graph for this function:

sum_simd()

double kcenon::monitoring::simd_aggregator::sum_simd ( const std::vector< double > & data ) const

inlineprivate

Definition at line 462 of file simd_aggregator.h.

                                                         {
#if defined(SIMD_AVX2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)) && defined(__AVX2__)
        const size_t simd_width = 4;  // AVX processes 4 doubles at a time
        size_t simd_count = data.size() / simd_width;
 
        __m256d sum_vec = _mm256_setzero_pd();
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m256d vec = _mm256_loadu_pd(&data[i * simd_width]);
            sum_vec = _mm256_add_pd(sum_vec, vec);
        }
 
        // Horizontal sum
        alignas(32) double temp[4];
        _mm256_storeu_pd(temp, sum_vec);
        double result = temp[0] + temp[1] + temp[2] + temp[3];
 
        // Handle remaining elements
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result += data[i];
        }
 
        return result;
#elif defined(SIMD_SSE2_AVAILABLE) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86))
        const size_t simd_width = 2;  // SSE processes 2 doubles at a time
        size_t simd_count = data.size() / simd_width;
 
        __m128d sum_vec = _mm_setzero_pd();
 
        for (size_t i = 0; i < simd_count; ++i) {
            __m128d vec = _mm_loadu_pd(&data[i * simd_width]);
            sum_vec = _mm_add_pd(sum_vec, vec);
        }
 
        alignas(16) double temp[2];
        _mm_storeu_pd(temp, sum_vec);
        double result = temp[0] + temp[1];
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result += data[i];
        }
 
        return result;
#elif defined(SIMD_NEON_AVAILABLE) && (defined(__aarch64__) || defined(_M_ARM64))
        const size_t simd_width = 2;  // NEON processes 2 doubles at a time
        size_t simd_count = data.size() / simd_width;
 
        float64x2_t sum_vec = vdupq_n_f64(0.0);
 
        for (size_t i = 0; i < simd_count; ++i) {
            float64x2_t vec = vld1q_f64(&data[i * simd_width]);
            sum_vec = vaddq_f64(sum_vec, vec);
        }
 
        double result = vgetq_lane_f64(sum_vec, 0) + vgetq_lane_f64(sum_vec, 1);
 
        for (size_t i = simd_count * simd_width; i < data.size(); ++i) {
            result += data[i];
        }
 
        return result;
#else
        return sum_scalar(data);
#endif
    }

References sum_scalar().

Referenced by sum().

Here is the call graph for this function:

Here is the caller graph for this function:

test_simd()

common::Result< bool > kcenon::monitoring::simd_aggregator::test_simd ( )

inline

Self-test SIMD functionality.

Returns

common::Result<bool> indicating if SIMD is working correctly

Definition at line 386 of file simd_aggregator.h.

                                   {
        // Create test data
        std::vector<double> test_data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
 
        // Test sum
        auto sum_result = sum(test_data);
        if (sum_result.is_err()) {
            return common::ok(false);
        }
 
        if (std::abs(sum_result.value() - 36.0) > 1e-10) {
            return common::ok(false);
        }
 
        // Test mean
        auto mean_result = mean(test_data);
        if (mean_result.is_err()) {
            return common::ok(false);
        }
 
        if (std::abs(mean_result.value() - 4.5) > 1e-10) {
            return common::ok(false);
        }
 
        // Test min/max
        auto min_result = min(test_data);
        auto max_result = max(test_data);
 
        if (min_result.is_err() || max_result.is_err()) {
            return common::ok(false);
        }
 
        if (std::abs(min_result.value() - 1.0) > 1e-10 ||
            std::abs(max_result.value() - 8.0) > 1e-10) {
            return common::ok(false);
        }
 
        return common::ok(true);
    }

References max(), mean(), min(), and sum().

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

variance()

common::Result< double > kcenon::monitoring::simd_aggregator::variance ( const std::vector< double > & data )

inline

Calculate variance of elements.

Parameters

data	Input data vector

Returns

common::Result<double> containing variance

Definition at line 305 of file simd_aggregator.h.

                                                                 {
        if (data.empty()) {
            return common::Result<double>::err(error_info(monitoring_error_code::invalid_argument, "Cannot compute variance of empty data").to_common_error());
        }
 
        if (data.size() == 1) {
            return common::ok(0.0);
        }
 
        auto mean_result = mean(data);
        if (mean_result.is_err()) {
            return mean_result;
        }
 
        double data_mean = mean_result.value();
        double sum_sq_diff = 0.0;
 
        for (const auto& val : data) {
            double diff = val - data_mean;
            sum_sq_diff += diff * diff;
        }
 
        return common::ok(sum_sq_diff / static_cast<double>(data.size() - 1));
    }

References kcenon::monitoring::invalid_argument, and mean().

Referenced by compute_summary(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

capabilities_

simd_capabilities kcenon::monitoring::simd_aggregator::capabilities_

private

Definition at line 665 of file simd_aggregator.h.

Referenced by get_capabilities(), and should_use_simd().

config_

simd_config kcenon::monitoring::simd_aggregator::config_

private

Definition at line 664 of file simd_aggregator.h.

Referenced by should_use_simd().

stats_

simd_aggregator_statistics kcenon::monitoring::simd_aggregator::stats_

mutableprivate

Definition at line 666 of file simd_aggregator.h.

Referenced by get_statistics(), max(), min(), reset_statistics(), and sum().

---

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

• include/kcenon/monitoring/optimization/simd_aggregator.h