test_optimization.cpp File Reference

#include <gtest/gtest.h>
#include <kcenon/monitoring/optimization/lockfree_queue.h>
#include <kcenon/monitoring/optimization/memory_pool.h>
#include <kcenon/monitoring/optimization/simd_aggregator.h>
#include <chrono>
#include <thread>
#include <vector>
#include <random>
#include <functional>

Include dependency graph for test_optimization.cpp:

Go to the source code of this file.

Classes
class	OptimizationTest
	Test suite for Phase 3 P4: Lock-free data structures integration. More...

Functions
	TEST_F (OptimizationTest, LockfreeQueueBasicOperations)
	TEST_F (OptimizationTest, LockfreeQueueConcurrentAccess)
	TEST_F (OptimizationTest, LockfreeQueueMovePush)
	TEST_F (OptimizationTest, LockfreeQueuePopEmpty)
	TEST_F (OptimizationTest, LockfreeQueuePushFull)
	TEST_F (OptimizationTest, LockfreeQueueConfigValidationAllCases)
	TEST_F (OptimizationTest, LockfreeQueueStatisticsReset)
	TEST_F (OptimizationTest, LockfreeQueueMoveConstructor)
	TEST_F (OptimizationTest, LockfreeQueueFactoryWithConfig)
	TEST_F (OptimizationTest, MemoryPoolBasicOperations)
	TEST_F (OptimizationTest, MemoryPoolObjectAllocation)
	TEST_F (OptimizationTest, MemoryPoolConcurrentAccess)
	TEST_F (OptimizationTest, MemoryPoolConfigValidationAllCases)
	TEST_F (OptimizationTest, MemoryPoolAllocateWhenFull)
	TEST_F (OptimizationTest, MemoryPoolDeallocateNullptr)
	TEST_F (OptimizationTest, MemoryPoolDeallocateForeignPtr)
	TEST_F (OptimizationTest, MemoryPoolAllocateObjectOversized)
	TEST_F (OptimizationTest, SIMDAggregatorBasicOperations)
	TEST_F (OptimizationTest, SIMDAggregatorLargeDataset)
	TEST_F (OptimizationTest, SIMDAggregatorPerformanceComparison)
	TEST_F (OptimizationTest, SIMDAggregatorEmptyInput)
	TEST_F (OptimizationTest, SIMDAggregatorVarianceSingleValue)
	TEST_F (OptimizationTest, SIMDAggregatorScalarOnlyMode)
	TEST_F (OptimizationTest, SIMDAggregatorSelfTest)
	TEST_F (OptimizationTest, SIMDConfigValidationAllCases)
	TEST_F (OptimizationTest, ConfigurationValidation)
	TEST_F (OptimizationTest, FactoryFunctions)
	TEST_F (OptimizationTest, DefaultConfigurations)
	TEST_F (OptimizationTest, IntegrationTest)

Function Documentation

TEST_F() [1/29]

TEST_F	(	OptimizationTest	,
		ConfigurationValidation	)

Definition at line 715 of file test_optimization.cpp.

                                                  {
    // Test lockfree queue config validation
    lockfree_queue_config invalid_queue_config;
    invalid_queue_config.initial_capacity = 0;  // Invalid
    EXPECT_FALSE(invalid_queue_config.validate());
    
    lockfree_queue_config valid_queue_config;
    valid_queue_config.initial_capacity = 1024;
    valid_queue_config.max_capacity = 4096;
    EXPECT_TRUE(valid_queue_config.validate());
    
    // Test memory pool config validation
    memory_pool_config invalid_pool_config;
    invalid_pool_config.block_size = 7;  // Not 8-byte aligned
    EXPECT_FALSE(invalid_pool_config.validate());
    
    memory_pool_config valid_pool_config;
    valid_pool_config.initial_blocks = 256;
    valid_pool_config.max_blocks = 1024;
    valid_pool_config.block_size = 64;
    EXPECT_TRUE(valid_pool_config.validate());
    
    // Test SIMD config validation
    simd_config invalid_simd_config;
    invalid_simd_config.vector_size = 7;  // Not power of 2
    EXPECT_FALSE(invalid_simd_config.validate());
    
    simd_config valid_simd_config;
    valid_simd_config.vector_size = 8;
    valid_simd_config.alignment = 32;
    EXPECT_TRUE(valid_simd_config.validate());
}

References kcenon::monitoring::simd_config::alignment, kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool_config::initial_blocks, kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::memory_pool_config::max_blocks, kcenon::monitoring::lockfree_queue_config::max_capacity, kcenon::monitoring::lockfree_queue_config::validate(), kcenon::monitoring::memory_pool_config::validate(), kcenon::monitoring::simd_config::validate(), and kcenon::monitoring::simd_config::vector_size.

Here is the call graph for this function:

TEST_F() [2/29]

TEST_F	(	OptimizationTest	,
		DefaultConfigurations	)

Definition at line 771 of file test_optimization.cpp.

                                                {
    // Test default queue configurations
    auto queue_configs = create_default_queue_configs();
    EXPECT_GE(queue_configs.size(), 3);
    
    for (const auto& config : queue_configs) {
        EXPECT_TRUE(config.validate());
    }
    
    // Test default pool configurations
    auto pool_configs = create_default_pool_configs();
    EXPECT_GE(pool_configs.size(), 3);
    
    for (const auto& config : pool_configs) {
        EXPECT_TRUE(config.validate());
    }
    
    // Test default SIMD configurations
    auto simd_configs = create_default_simd_configs();
    EXPECT_GE(simd_configs.size(), 3);
    
    for (const auto& config : simd_configs) {
        EXPECT_TRUE(config.validate());
    }
}

References kcenon::monitoring::create_default_pool_configs(), kcenon::monitoring::create_default_queue_configs(), and kcenon::monitoring::create_default_simd_configs().

Here is the call graph for this function:

TEST_F() [3/29]

TEST_F	(	OptimizationTest	,
		FactoryFunctions	)

Definition at line 749 of file test_optimization.cpp.

                                           {
    // Test lockfree queue factory
    auto queue = make_lockfree_queue<int>();
    EXPECT_NE(queue, nullptr);
    EXPECT_TRUE(queue->empty());
    
    // Test memory pool factory
    auto pool = make_memory_pool();
    EXPECT_NE(pool, nullptr);
    EXPECT_GT(pool->available_blocks(), 0);
    
    // Test SIMD aggregator factory
    auto aggregator = make_simd_aggregator();
    EXPECT_NE(aggregator, nullptr);
    
    // Test SIMD functionality
    auto test_result = aggregator->test_simd();
    EXPECT_TRUE(test_result.is_ok());
    EXPECT_TRUE(test_result.value());
}

References kcenon::monitoring::make_lockfree_queue(), kcenon::monitoring::make_memory_pool(), and kcenon::monitoring::make_simd_aggregator().

Here is the call graph for this function:

TEST_F() [4/29]

TEST_F	(	OptimizationTest	,
		IntegrationTest	)

Definition at line 798 of file test_optimization.cpp.

                                          {
    // Test integration of all optimization components
    lockfree_queue<double> queue;
    memory_pool pool;
    simd_aggregator aggregator;
    
    // Generate data and push to queue
    auto test_data = generate_test_data(1000);
    
    for (double value : test_data) {
        auto result = queue.push(value);
        EXPECT_TRUE(result.is_ok());
    }
    
    // Pop data from queue and collect in vector
    std::vector<double> collected_data;
    collected_data.reserve(test_data.size());
    
    while (!queue.empty()) {
        auto result = queue.pop();
        if (result.is_ok()) {
            collected_data.push_back(result.value());
        }
    }
    
    EXPECT_EQ(collected_data.size(), test_data.size());
    
    // Use SIMD aggregator to process collected data
    auto summary = aggregator.compute_summary(collected_data);
    EXPECT_TRUE(summary.is_ok());
    
    const auto& stats = summary.value();
    EXPECT_EQ(stats.count, test_data.size());
    EXPECT_GT(stats.sum, 0.0);
    EXPECT_GT(stats.mean, 0.0);
    
    // Verify statistics from all components
    const auto& queue_stats = queue.get_statistics();
    const auto& pool_stats = pool.get_statistics();
    const auto& simd_stats = aggregator.get_statistics();
    
    EXPECT_GT(queue_stats.get_push_success_rate(), 99.0);
    EXPECT_GT(queue_stats.get_pop_success_rate(), 99.0);
    EXPECT_GT(pool_stats.get_allocation_success_rate(), 99.0);
    EXPECT_GT(simd_stats.total_elements_processed.load(), 0);
}

References kcenon::monitoring::simd_aggregator::compute_summary(), kcenon::monitoring::lockfree_queue< T >::empty(), kcenon::monitoring::lockfree_queue< T >::get_statistics(), kcenon::monitoring::memory_pool::get_statistics(), kcenon::monitoring::simd_aggregator::get_statistics(), kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::lockfree_queue< T >::push(), and kcenon::monitoring::summary.

Here is the call graph for this function:

TEST_F() [5/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueBasicOperations	)

Definition at line 50 of file test_optimization.cpp.

                                                       {
    lockfree_queue_config config;
    config.initial_capacity = 16;
    config.max_capacity = 64;
    
    lockfree_queue<int> queue(config);
    
    EXPECT_TRUE(queue.empty());
    EXPECT_EQ(queue.size(), 0);
    
    // Push elements
    for (int i = 0; i < 10; ++i) {
        auto result = queue.push(i);
        EXPECT_TRUE(result.is_ok()) << "Failed to push " << i;
    }
 
    EXPECT_FALSE(queue.empty());
    EXPECT_EQ(queue.size(), 10);
 
    // Pop elements
    for (int i = 0; i < 10; ++i) {
        auto result = queue.pop();
        EXPECT_TRUE(result.is_ok()) << "Failed to pop element " << i;
        EXPECT_EQ(result.value(), i);
    }
    
    EXPECT_TRUE(queue.empty());
    EXPECT_EQ(queue.size(), 0);
}

References kcenon::monitoring::lockfree_queue< T >::empty(), kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::lockfree_queue_config::max_capacity, kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::lockfree_queue< T >::push(), and kcenon::monitoring::lockfree_queue< T >::size().

Here is the call graph for this function:

TEST_F() [6/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueConcurrentAccess	)

Definition at line 80 of file test_optimization.cpp.

                                                        {
    lockfree_queue_config config;
    config.initial_capacity = 1024;
    config.max_capacity = 4096;
    
    lockfree_queue<int> queue(config);
    
    const int num_producers = 4;
    const int num_consumers = 2;
    const int items_per_producer = 1000;
    
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;
    std::atomic<int> total_consumed{0};
    std::atomic<bool> producers_done{false};
    
    // Start producers
    for (int p = 0; p < num_producers; ++p) {
        producers.emplace_back([&queue, p]() {
            for (int i = 0; i < 1000; ++i) {
                int value = p * 1000 + i;
                auto result = queue.push(value);
                while (!result.is_ok() || !result.value()) {
                    std::this_thread::yield();
                    result = queue.push(value);
                }
            }
        });
    }
    
    // Start consumers
    for (int c = 0; c < num_consumers; ++c) {
        consumers.emplace_back([&queue, &total_consumed, &producers_done]() {
            while (!producers_done.load() || !queue.empty()) {
                auto result = queue.pop();
                if (result.is_ok()) {
                    total_consumed.fetch_add(1);
                } else {
                    std::this_thread::yield();
                }
            }
        });
    }
    
    // Wait for producers
    for (auto& producer : producers) {
        producer.join();
    }
    producers_done.store(true);
    
    // Wait for consumers
    for (auto& consumer : consumers) {
        consumer.join();
    }
    
    EXPECT_EQ(total_consumed.load(), num_producers * items_per_producer);
    EXPECT_TRUE(queue.empty());
 
    const auto& stats = queue.get_statistics();
    // Push success rate should be high since we retry until success
    // Lower threshold to 30% for CI environments with sanitizer overhead
    // ThreadSanitizer in particular can significantly slow down atomic
    // operations, causing more contention, retries, and lower success rates
    EXPECT_GT(stats.get_push_success_rate(), 30.0);
    // Pop failures are expected when queue is empty (consumers waiting for data)
    // so we only check that successful pops equals total consumed
    EXPECT_EQ(stats.pop_successes.load(), static_cast<size_t>(total_consumed.load()));
}

References kcenon::monitoring::consumer, kcenon::monitoring::lockfree_queue< T >::empty(), kcenon::monitoring::lockfree_queue< T >::get_statistics(), kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::lockfree_queue_config::max_capacity, kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::producer, and kcenon::monitoring::lockfree_queue< T >::push().

Here is the call graph for this function:

TEST_F() [7/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueConfigValidationAllCases	)

Definition at line 195 of file test_optimization.cpp.

                                                                {
    // Valid config
    lockfree_queue_config valid;
    valid.initial_capacity = 16;
    valid.max_capacity = 64;
    EXPECT_TRUE(valid.validate());
 
    // Zero initial capacity
    lockfree_queue_config zero_cap;
    zero_cap.initial_capacity = 0;
    EXPECT_FALSE(zero_cap.validate());
 
    // max_capacity < initial_capacity
    lockfree_queue_config max_less;
    max_less.initial_capacity = 100;
    max_less.max_capacity = 50;
    EXPECT_FALSE(max_less.validate());
 
    // max_capacity == 0 (unlimited) should be valid
    lockfree_queue_config unlimited;
    unlimited.initial_capacity = 16;
    unlimited.max_capacity = 0;
    EXPECT_TRUE(unlimited.validate());
}

References kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::lockfree_queue_config::max_capacity, kcenon::monitoring::valid, and kcenon::monitoring::lockfree_queue_config::validate().

Here is the call graph for this function:

TEST_F() [8/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueFactoryWithConfig	)

Definition at line 275 of file test_optimization.cpp.

                                                         {
    lockfree_queue_config config;
    config.initial_capacity = 32;
    config.max_capacity = 128;
 
    auto queue = make_lockfree_queue<double>(config);
    EXPECT_NE(queue, nullptr);
    EXPECT_TRUE(queue->empty());
    EXPECT_EQ(queue->capacity(), 32);
}

References kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::make_lockfree_queue(), and kcenon::monitoring::lockfree_queue_config::max_capacity.

Here is the call graph for this function:

TEST_F() [9/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueMoveConstructor	)

Definition at line 247 of file test_optimization.cpp.

                                                       {
    lockfree_queue_config config;
    config.initial_capacity = 16;
    config.max_capacity = 64;
 
    lockfree_queue<int> queue1(config);
    queue1.push(10);
    queue1.push(20);
    queue1.push(30);
 
    // Move constructor
    lockfree_queue<int> queue2(std::move(queue1));
    EXPECT_EQ(queue2.size(), 3);
 
    auto pop_result = queue2.pop();
    EXPECT_TRUE(pop_result.is_ok());
    EXPECT_EQ(pop_result.value(), 10);
 
    pop_result = queue2.pop();
    EXPECT_TRUE(pop_result.is_ok());
    EXPECT_EQ(pop_result.value(), 20);
 
    pop_result = queue2.pop();
    EXPECT_TRUE(pop_result.is_ok());
    EXPECT_EQ(pop_result.value(), 30);
}

References kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::lockfree_queue_config::max_capacity, kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::lockfree_queue< T >::push(), and kcenon::monitoring::lockfree_queue< T >::size().

Here is the call graph for this function:

TEST_F() [10/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueMovePush	)

Definition at line 150 of file test_optimization.cpp.

                                                {
    lockfree_queue<std::string> queue;
 
    std::string value = "test_value";
    auto result = queue.push(std::move(value));
    EXPECT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
    EXPECT_EQ(queue.size(), 1);
 
    auto pop_result = queue.pop();
    EXPECT_TRUE(pop_result.is_ok());
    EXPECT_EQ(pop_result.value(), "test_value");
}

References kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::lockfree_queue< T >::push(), and kcenon::monitoring::lockfree_queue< T >::size().

Here is the call graph for this function:

TEST_F() [11/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueuePopEmpty	)

Definition at line 165 of file test_optimization.cpp.

                                                {
    lockfree_queue<int> queue;
    EXPECT_TRUE(queue.empty());
 
    auto result = queue.pop();
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::lockfree_queue< T >::empty(), and kcenon::monitoring::lockfree_queue< T >::pop().

Here is the call graph for this function:

TEST_F() [12/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueuePushFull	)

Definition at line 174 of file test_optimization.cpp.

                                                {
    lockfree_queue_config config;
    config.initial_capacity = 4;
    config.max_capacity = 4;
 
    lockfree_queue<int> queue(config);
 
    // Fill the queue to capacity
    for (int i = 0; i < 4; ++i) {
        auto result = queue.push(i);
        EXPECT_TRUE(result.is_ok());
        EXPECT_TRUE(result.value());
    }
 
    // Next push should return ok(false)
    auto full_result = queue.push(999);
    EXPECT_TRUE(full_result.is_ok());
    EXPECT_FALSE(full_result.value());
}

References kcenon::monitoring::lockfree_queue_config::initial_capacity, kcenon::monitoring::lockfree_queue_config::max_capacity, and kcenon::monitoring::lockfree_queue< T >::push().

Here is the call graph for this function:

TEST_F() [13/29]

TEST_F	(	OptimizationTest	,
		LockfreeQueueStatisticsReset	)

Definition at line 221 of file test_optimization.cpp.

                                                       {
    lockfree_queue<int> queue;
 
    queue.push(1);
    queue.push(2);
    queue.pop();
 
    const auto& stats = queue.get_statistics();
    EXPECT_GT(stats.push_attempts.load(), 0);
    EXPECT_GT(stats.pop_attempts.load(), 0);
 
    queue.reset_statistics();
 
    EXPECT_EQ(stats.push_attempts.load(), 0);
    EXPECT_EQ(stats.push_successes.load(), 0);
    EXPECT_EQ(stats.push_failures.load(), 0);
    EXPECT_EQ(stats.pop_attempts.load(), 0);
    EXPECT_EQ(stats.pop_successes.load(), 0);
    EXPECT_EQ(stats.pop_failures.load(), 0);
 
    // Success rate should be 100.0 when attempts == 0
    EXPECT_DOUBLE_EQ(stats.get_push_success_rate(), 100.0);
    EXPECT_DOUBLE_EQ(stats.get_pop_success_rate(), 100.0);
}

References kcenon::monitoring::lockfree_queue< T >::get_statistics(), kcenon::monitoring::lockfree_queue< T >::pop(), kcenon::monitoring::lockfree_queue< T >::push(), and kcenon::monitoring::lockfree_queue< T >::reset_statistics().

Here is the call graph for this function:

TEST_F() [14/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolAllocateObjectOversized	)

Definition at line 494 of file test_optimization.cpp.

                                                            {
    memory_pool_config config;
    config.initial_blocks = 16;
    config.block_size = 8;  // Very small blocks
 
    memory_pool pool(config);
 
    struct LargeObject {
        double data[16];  // 128 bytes > 8 bytes block_size
    };
 
    auto result = pool.allocate_object<LargeObject>();
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::memory_pool::allocate_object(), kcenon::monitoring::memory_pool_config::block_size, and kcenon::monitoring::memory_pool_config::initial_blocks.

Here is the call graph for this function:

TEST_F() [15/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolAllocateWhenFull	)

Definition at line 449 of file test_optimization.cpp.

                                                     {
    memory_pool_config config;
    config.initial_blocks = 4;
    config.max_blocks = 4;  // Cannot grow
    config.block_size = 64;
 
    memory_pool pool(config);
 
    // Allocate all blocks
    std::vector<void*> allocated;
    for (int i = 0; i < 4; ++i) {
        auto result = pool.allocate();
        EXPECT_TRUE(result.is_ok());
        allocated.push_back(result.value());
    }
    EXPECT_EQ(pool.available_blocks(), 0);
 
    // Next allocation should fail with resource_unavailable
    auto fail_result = pool.allocate();
    EXPECT_TRUE(fail_result.is_err());
 
    // Cleanup
    for (auto* ptr : allocated) {
        pool.deallocate(ptr);
    }
}

References kcenon::monitoring::memory_pool::allocate(), kcenon::monitoring::memory_pool::available_blocks(), kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool::deallocate(), kcenon::monitoring::memory_pool_config::initial_blocks, and kcenon::monitoring::memory_pool_config::max_blocks.

Here is the call graph for this function:

TEST_F() [16/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolBasicOperations	)

Definition at line 287 of file test_optimization.cpp.

                                                    {
    memory_pool_config config;
    config.initial_blocks = 64;
    config.max_blocks = 256;
    config.block_size = 128;
    
    memory_pool pool(config);
    
    EXPECT_GT(pool.available_blocks(), 0);
    EXPECT_EQ(pool.total_blocks(), 64);
    
    // Allocate memory blocks
    std::vector<void*> allocated_blocks;
    for (int i = 0; i < 32; ++i) {
        auto result = pool.allocate();
        EXPECT_TRUE(result.is_ok()) << "Failed to allocate block " << i;
        allocated_blocks.push_back(result.value());
    }
    
    EXPECT_EQ(pool.available_blocks(), 32);  // 64 - 32 = 32
    
    // Deallocate blocks
    for (auto* ptr : allocated_blocks) {
        auto result = pool.deallocate(ptr);
        EXPECT_TRUE(result.is_ok());
    }
    
    EXPECT_EQ(pool.available_blocks(), 64);  // All blocks returned
    
    const auto& stats = pool.get_statistics();
    EXPECT_EQ(stats.total_allocations.load(), 32);
    EXPECT_EQ(stats.total_deallocations.load(), 32);
    EXPECT_GT(stats.get_allocation_success_rate(), 99.0);
}

References kcenon::monitoring::memory_pool::allocate(), kcenon::monitoring::memory_pool::available_blocks(), kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool::deallocate(), kcenon::monitoring::memory_pool::get_statistics(), kcenon::monitoring::memory_pool_config::initial_blocks, kcenon::monitoring::memory_pool_config::max_blocks, and kcenon::monitoring::memory_pool::total_blocks().

Here is the call graph for this function:

TEST_F() [17/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolConcurrentAccess	)

Definition at line 356 of file test_optimization.cpp.

                                                     {
    memory_pool_config config;
    config.initial_blocks = 1024;
    config.max_blocks = 4096;
    config.block_size = 64;
    config.use_thread_local_cache = true;
    
    memory_pool pool(config);
    
    const int num_threads = 8;
    const int operations_per_thread = 500;
    
    std::vector<std::thread> threads;
    std::atomic<int> successful_operations{0};
    
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([&pool, &successful_operations, operations_per_thread]() {
            std::vector<void*> allocated_ptrs;
            
            // Allocate
            for (int i = 0; i < operations_per_thread; ++i) {
                auto result = pool.allocate();
                if (result.is_ok()) {
                    allocated_ptrs.push_back(result.value());
                }
            }
            
            // Deallocate
            for (auto* ptr : allocated_ptrs) {
                auto result = pool.deallocate(ptr);
                if (result.is_ok()) {
                    successful_operations.fetch_add(1);
                }
            }
        });
    }
    
    for (auto& thread : threads) {
        thread.join();
    }
    
    EXPECT_GT(successful_operations.load(), num_threads * operations_per_thread * 0.85);  // Relaxed for concurrent access
    
    const auto& stats = pool.get_statistics();
    EXPECT_GT(stats.get_allocation_success_rate(), 95.0);
}

References kcenon::monitoring::memory_pool::allocate(), kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool::deallocate(), kcenon::monitoring::memory_pool::get_statistics(), kcenon::monitoring::memory_pool_config::initial_blocks, kcenon::monitoring::memory_pool_config::max_blocks, and kcenon::monitoring::memory_pool_config::use_thread_local_cache.

Here is the call graph for this function:

TEST_F() [18/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolConfigValidationAllCases	)

Definition at line 404 of file test_optimization.cpp.

                                                             {
    // Valid config
    memory_pool_config valid;
    valid.initial_blocks = 64;
    valid.max_blocks = 256;
    valid.block_size = 64;
    valid.alignment = 8;
    EXPECT_TRUE(valid.validate());
 
    // Zero initial blocks
    memory_pool_config zero_blocks;
    zero_blocks.initial_blocks = 0;
    EXPECT_FALSE(zero_blocks.validate());
 
    // Zero block size
    memory_pool_config zero_size;
    zero_size.block_size = 0;
    EXPECT_FALSE(zero_size.validate());
 
    // Block size not 8-byte aligned
    memory_pool_config bad_align;
    bad_align.block_size = 13;
    EXPECT_FALSE(bad_align.validate());
 
    // Alignment not power of 2
    memory_pool_config bad_pow2;
    bad_pow2.block_size = 64;
    bad_pow2.alignment = 6;
    EXPECT_FALSE(bad_pow2.validate());
 
    // Zero alignment
    memory_pool_config zero_align;
    zero_align.block_size = 64;
    zero_align.alignment = 0;
    EXPECT_FALSE(zero_align.validate());
 
    // max_blocks < initial_blocks
    memory_pool_config max_less;
    max_less.initial_blocks = 100;
    max_less.max_blocks = 50;
    max_less.block_size = 64;
    EXPECT_FALSE(max_less.validate());
}

References kcenon::monitoring::memory_pool_config::alignment, kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool_config::initial_blocks, kcenon::monitoring::memory_pool_config::max_blocks, kcenon::monitoring::valid, and kcenon::monitoring::memory_pool_config::validate().

Here is the call graph for this function:

TEST_F() [19/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolDeallocateForeignPtr	)

Definition at line 485 of file test_optimization.cpp.

                                                         {
    memory_pool pool;
 
    int foreign_value = 42;
    auto result = pool.deallocate(&foreign_value);
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::memory_pool::deallocate().

Here is the call graph for this function:

TEST_F() [20/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolDeallocateNullptr	)

Definition at line 477 of file test_optimization.cpp.

                                                      {
    memory_pool pool;
 
    auto result = pool.deallocate(nullptr);
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::memory_pool::deallocate().

Here is the call graph for this function:

TEST_F() [21/29]

TEST_F	(	OptimizationTest	,
		MemoryPoolObjectAllocation	)

Definition at line 322 of file test_optimization.cpp.

                                                     {
    memory_pool_config config;
    config.initial_blocks = 128;
    config.block_size = 64;  // Enough for test objects
    
    memory_pool pool(config);
    
    struct TestObject {
        int value;
        double data;
        
        TestObject(int v, double d) : value(v), data(d) {}
    };
    
    // Allocate objects
    std::vector<TestObject*> objects;
    for (int i = 0; i < 50; ++i) {
        auto result = pool.allocate_object<TestObject>(i, i * 0.5);
        EXPECT_TRUE(result.is_ok()) << "Failed to allocate object " << i;
 
        auto* obj = result.value();
        EXPECT_EQ(obj->value, i);
        EXPECT_DOUBLE_EQ(obj->data, i * 0.5);
 
        objects.push_back(obj);
    }
    
    // Deallocate objects
    for (auto* obj : objects) {
        auto result = pool.deallocate_object(obj);
        EXPECT_TRUE(result.is_ok());
    }
}

References kcenon::monitoring::memory_pool::allocate_object(), kcenon::monitoring::memory_pool_config::block_size, kcenon::monitoring::memory_pool::deallocate_object(), and kcenon::monitoring::memory_pool_config::initial_blocks.

Here is the call graph for this function:

TEST_F() [22/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorBasicOperations	)

Definition at line 510 of file test_optimization.cpp.

                                                        {
    simd_config config;
    simd_aggregator aggregator(config);
    
    std::vector<double> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
    
    // Test sum
    auto sum_result = aggregator.sum(data);
    EXPECT_TRUE(sum_result.is_ok());
    EXPECT_DOUBLE_EQ(sum_result.value(), 36.0);
 
    // Test mean
    auto mean_result = aggregator.mean(data);
    EXPECT_TRUE(mean_result.is_ok());
    EXPECT_DOUBLE_EQ(mean_result.value(), 4.5);
 
    // Test min/max
    auto min_result = aggregator.min(data);
    EXPECT_TRUE(min_result.is_ok());
    EXPECT_DOUBLE_EQ(min_result.value(), 1.0);
 
    auto max_result = aggregator.max(data);
    EXPECT_TRUE(max_result.is_ok());
    EXPECT_DOUBLE_EQ(max_result.value(), 8.0);
 
    // Test variance
    auto var_result = aggregator.variance(data);
    EXPECT_TRUE(var_result.is_ok());
    EXPECT_GT(var_result.value(), 0.0);  // Should be positive for this dataset
}

References kcenon::monitoring::simd_aggregator::max(), kcenon::monitoring::simd_aggregator::mean(), kcenon::monitoring::simd_aggregator::min(), kcenon::monitoring::simd_aggregator::sum(), and kcenon::monitoring::simd_aggregator::variance().

Here is the call graph for this function:

TEST_F() [23/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorEmptyInput	)

Definition at line 623 of file test_optimization.cpp.

                                                   {
    simd_aggregator aggregator;
    std::vector<double> empty_data;
 
    auto sum_result = aggregator.sum(empty_data);
    EXPECT_TRUE(sum_result.is_err());
 
    auto mean_result = aggregator.mean(empty_data);
    EXPECT_TRUE(mean_result.is_err());
 
    auto min_result = aggregator.min(empty_data);
    EXPECT_TRUE(min_result.is_err());
 
    auto max_result = aggregator.max(empty_data);
    EXPECT_TRUE(max_result.is_err());
 
    auto var_result = aggregator.variance(empty_data);
    EXPECT_TRUE(var_result.is_err());
 
    auto summary_result = aggregator.compute_summary(empty_data);
    EXPECT_TRUE(summary_result.is_err());
}

References kcenon::monitoring::simd_aggregator::compute_summary(), kcenon::monitoring::simd_aggregator::max(), kcenon::monitoring::simd_aggregator::mean(), kcenon::monitoring::simd_aggregator::min(), kcenon::monitoring::simd_aggregator::sum(), and kcenon::monitoring::simd_aggregator::variance().

Here is the call graph for this function:

TEST_F() [24/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorLargeDataset	)

Definition at line 541 of file test_optimization.cpp.

                                                     {
    simd_config config;
    config.enable_simd = true;
    simd_aggregator aggregator(config);
    
    // Generate large dataset
    auto data = generate_test_data(10000, 0.0, 100.0);
    
    // Test statistical summary
    auto summary_result = aggregator.compute_summary(data);
    EXPECT_TRUE(summary_result.is_ok());
    
    const auto& summary = summary_result.value();
    EXPECT_EQ(summary.count, 10000);
    EXPECT_GT(summary.sum, 0.0);
    EXPECT_GT(summary.mean, 0.0);
    EXPECT_LT(summary.mean, 100.0);
    EXPECT_GT(summary.variance, 0.0);
    EXPECT_GT(summary.std_dev, 0.0);
    EXPECT_GE(summary.min_val, 0.0);
    EXPECT_LE(summary.max_val, 100.0);
    EXPECT_LT(summary.min_val, summary.max_val);
    
    // Check SIMD utilization
    const auto& stats = aggregator.get_statistics();
    if (aggregator.get_capabilities().avx2_available || aggregator.get_capabilities().neon_available) {
        EXPECT_GT(stats.get_simd_utilization(), 0.0);
    }
}

References kcenon::monitoring::simd_capabilities::avx2_available, kcenon::monitoring::simd_aggregator::compute_summary(), kcenon::monitoring::simd_config::enable_simd, kcenon::monitoring::simd_aggregator::get_capabilities(), kcenon::monitoring::simd_aggregator::get_statistics(), kcenon::monitoring::simd_capabilities::neon_available, and kcenon::monitoring::summary.

Here is the call graph for this function:

TEST_F() [25/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorPerformanceComparison	)

Definition at line 571 of file test_optimization.cpp.

                                                              {
    // Test SIMD vs scalar performance
    simd_config simd_cfg;
    simd_cfg.enable_simd = true;
    
    simd_config scalar_cfg;
    scalar_cfg.enable_simd = false;
    
    simd_aggregator simd_agg(simd_cfg);
    simd_aggregator scalar_agg(scalar_cfg);
    
    auto large_data = generate_test_data(50000, 0.0, 1000.0);
    
    // Measure SIMD performance
    auto start_simd = std::chrono::high_resolution_clock::now();
    auto simd_summary = simd_agg.compute_summary(large_data);
    auto end_simd = std::chrono::high_resolution_clock::now();
    
    // Measure scalar performance
    auto start_scalar = std::chrono::high_resolution_clock::now();
    auto scalar_summary = scalar_agg.compute_summary(large_data);
    auto end_scalar = std::chrono::high_resolution_clock::now();
    
    EXPECT_TRUE(simd_summary.is_ok());
    EXPECT_TRUE(scalar_summary.is_ok());
    
    // Results should be approximately equal
    const auto& simd_result = simd_summary.value();
    const auto& scalar_result = scalar_summary.value();
    
    EXPECT_NEAR(simd_result.sum, scalar_result.sum, 1e-6);
    EXPECT_NEAR(simd_result.mean, scalar_result.mean, 1e-6);
    EXPECT_NEAR(simd_result.min_val, scalar_result.min_val, 1e-6);
    EXPECT_NEAR(simd_result.max_val, scalar_result.max_val, 1e-6);
    
    auto simd_duration = std::chrono::duration_cast<std::chrono::microseconds>(end_simd - start_simd);
    auto scalar_duration = std::chrono::duration_cast<std::chrono::microseconds>(end_scalar - start_scalar);
    
    // SIMD should be faster or at least comparable (depending on data size and CPU)
    std::cout << "SIMD duration: " << simd_duration.count() << " μs" << std::endl;
    std::cout << "Scalar duration: " << scalar_duration.count() << " μs" << std::endl;
 
    if (simd_agg.get_capabilities().avx2_available || simd_agg.get_capabilities().neon_available) {
        // Performance comparison is informational only - CI environments may have
        // virtualization overhead or SIMD emulation that makes SIMD slower
        if (simd_duration.count() > scalar_duration.count() * 1.2) {
            std::cout << "[INFO] SIMD slower than scalar - this may be expected in CI/VM environments" << std::endl;
        }
    }
}

References kcenon::monitoring::simd_capabilities::avx2_available, kcenon::monitoring::simd_aggregator::compute_summary(), kcenon::monitoring::simd_config::enable_simd, kcenon::monitoring::simd_aggregator::get_capabilities(), and kcenon::monitoring::simd_capabilities::neon_available.

Here is the call graph for this function:

TEST_F() [26/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorScalarOnlyMode	)

Definition at line 657 of file test_optimization.cpp.

                                                       {
    simd_config config;
    config.enable_simd = false;
    simd_aggregator aggregator(config);
 
    auto data = generate_test_data(100, 0.0, 100.0);
 
    auto sum_result = aggregator.sum(data);
    EXPECT_TRUE(sum_result.is_ok());
 
    auto mean_result = aggregator.mean(data);
    EXPECT_TRUE(mean_result.is_ok());
 
    // All operations should use scalar path
    const auto& stats = aggregator.get_statistics();
    EXPECT_EQ(stats.simd_operations.load(), 0);
    EXPECT_GT(stats.scalar_operations.load(), 0);
    EXPECT_GT(stats.total_elements_processed.load(), 0);
}

References kcenon::monitoring::simd_config::enable_simd, kcenon::monitoring::simd_aggregator::get_statistics(), kcenon::monitoring::simd_aggregator::mean(), and kcenon::monitoring::simd_aggregator::sum().

Here is the call graph for this function:

TEST_F() [27/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorSelfTest	)

Definition at line 678 of file test_optimization.cpp.

                                                 {
    simd_aggregator aggregator;
    auto result = aggregator.test_simd();
    EXPECT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
}

References kcenon::monitoring::simd_aggregator::test_simd().

Here is the call graph for this function:

TEST_F() [28/29]

TEST_F	(	OptimizationTest	,
		SIMDAggregatorVarianceSingleValue	)

Definition at line 647 of file test_optimization.cpp.

                                                            {
    simd_aggregator aggregator;
    std::vector<double> single = {42.0};
 
    auto result = aggregator.variance(single);
    EXPECT_TRUE(result.is_ok());
    EXPECT_DOUBLE_EQ(result.value(), 0.0);
}

References kcenon::monitoring::simd_aggregator::variance().

Here is the call graph for this function:

TEST_F() [29/29]

TEST_F	(	OptimizationTest	,
		SIMDConfigValidationAllCases	)

Definition at line 686 of file test_optimization.cpp.

                                                       {
    // Valid config
    simd_config valid;
    valid.vector_size = 8;
    valid.alignment = 32;
    EXPECT_TRUE(valid.validate());
 
    // Zero vector size
    simd_config zero_vec;
    zero_vec.vector_size = 0;
    EXPECT_FALSE(zero_vec.validate());
 
    // Non-power-of-2 vector size
    simd_config bad_vec;
    bad_vec.vector_size = 5;
    EXPECT_FALSE(bad_vec.validate());
 
    // Zero alignment
    simd_config zero_align;
    zero_align.alignment = 0;
    EXPECT_FALSE(zero_align.validate());
 
    // Non-power-of-2 alignment
    simd_config bad_align;
    bad_align.alignment = 12;
    EXPECT_FALSE(bad_align.validate());
}

References kcenon::monitoring::simd_config::alignment, kcenon::monitoring::valid, kcenon::monitoring::simd_config::validate(), and kcenon::monitoring::simd_config::vector_size.

Here is the call graph for this function: