executor_example.cpp File Reference

#include <kcenon/common/interfaces/executor_interface.h>
#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <atomic>
#include <queue>
#include <mutex>
#include <condition_variable>

Include dependency graph for executor_example.cpp:

Go to the source code of this file.

Classes
class	mock_executor
class	function_job
class	calculation_job
class	example_executor_provider

Functions
void	process_data_batch (IExecutor &executor, const std::vector< int > &data)
int	main ()

Function Documentation

main()

int main

(

)

Definition at line 299 of file executor_example.cpp.

           {
    std::cout << "=== IExecutor Interface Examples ===\n\n";
 
    // Example 1: Basic usage
    std::cout << "1. Basic task execution:\n";
    mock_executor executor(2);
 
    auto job1 = std::make_unique<function_job>([] {
        std::cout << "   Task 1 executed\n";
    });
    auto result1 = executor.execute(std::move(job1));
    if (result1.is_ok()) {
        std::move(result1).value().wait();
    }
 
    auto job2 = std::make_unique<function_job>([] {
        std::cout << "   Task 2 executed\n";
    });
    auto result2 = executor.execute(std::move(job2));
    if (result2.is_ok()) {
        std::move(result2).value().wait();
    }
 
    // Example 2: Check executor status
    std::cout << "\n2. Executor status:\n";
    std::cout << "   Workers: " << executor.worker_count() << "\n";
    std::cout << "   Running: " << (executor.is_running() ? "yes" : "no") << "\n";
    std::cout << "   Pending: " << executor.pending_tasks() << "\n";
 
    // Example 3: Batch processing
    std::cout << "\n3. Batch processing:\n";
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    process_data_batch(executor, data);
 
    // Example 4: Using executor provider
    std::cout << "\n4. Using executor provider:\n";
    example_executor_provider provider;
    auto shared_executor = provider.get_executor();
 
    auto provider_job = std::make_unique<function_job>([] {
        std::cout << "   Task from shared executor\n";
    });
    auto provider_result = shared_executor->execute(std::move(provider_job));
    if (provider_result.is_ok()) {
        std::move(provider_result).value().wait();
    }
 
    // Example 5: Delayed execution
    std::cout << "\n5. Delayed execution:\n";
    std::cout << "   Scheduling delayed task...\n";
    auto start = std::chrono::steady_clock::now();
 
    auto delayed_job = std::make_unique<function_job>([start] {
        auto elapsed = std::chrono::steady_clock::now() - start;
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
        std::cout << "   Delayed task executed after " << ms.count() << "ms\n";
    });
 
    auto delayed_result = executor.execute_delayed(std::move(delayed_job), 500ms);
    if (delayed_result.is_ok()) {
        std::move(delayed_result).value().wait();
    }
 
    // Example 6: Error handling
    std::cout << "\n6. Error handling:\n";
    auto error_job = std::make_unique<function_job>([] {
        throw std::runtime_error("Task failed!");
    });
 
    auto error_result = executor.execute(std::move(error_job));
    if (error_result.is_ok()) {
        try {
            auto error_future = std::move(error_result.value());
            error_future.get();
        } catch (const std::exception& e) {
            std::cout << "   Caught exception: " << e.what() << "\n";
        }
    }
 
    // Example 7: Custom job execution
    std::cout << "\n7. Custom job execution:\n";
    {
        mock_executor job_executor(2);
        std::atomic<int> job_sum{0};
        std::vector<std::future<void>> job_futures;
 
        std::cout << "   Executing calculation jobs...\n";
        for (int i = 1; i <= 5; ++i) {
            auto job = std::make_unique<calculation_job>(i, job_sum);
            auto result = job_executor.execute(std::move(job));
 
            if (result.is_ok()) {
                job_futures.push_back(std::move(result.value()));
            } else {
                const auto& err = result.error();
                std::cout << "   Failed to execute job: "
                         << err.message << "\n";
            }
        }
 
        // Wait for all jobs to complete
        for (auto& future : job_futures) {
            future.wait();
        }
 
        std::cout << "   Custom job sum of squares: " << job_sum << "\n";
    }
 
    // Example 8: Graceful shutdown
    std::cout << "\n8. Graceful shutdown:\n";
 
    // Execute some tasks
    for (int i = 0; i < 5; ++i) {
        auto final_job = std::make_unique<function_job>([i] {
            std::this_thread::sleep_for(50ms);
            std::cout << "   Final task " << i << " completed\n";
        });
        executor.execute(std::move(final_job));
    }
 
    std::cout << "   Pending tasks before shutdown: "
              << executor.pending_tasks() << "\n";
    std::cout << "   Shutting down (waiting for completion)...\n";
 
    executor.shutdown(true);
    std::cout << "   Shutdown complete\n";
 
    std::cout << "\n=== Examples completed ===\n";
    return 0;
}

References kcenon::common::err(), kcenon::common::Result< T >::error(), mock_executor::execute(), mock_executor::execute_delayed(), example_executor_provider::get_executor(), mock_executor::is_running(), mock_executor::pending_tasks(), process_data_batch(), mock_executor::shutdown(), and mock_executor::worker_count().

Here is the call graph for this function:

process_data_batch()

void process_data_batch	(	IExecutor &	executor,
		const std::vector< int > &	data )

Example function that uses IExecutor interface

Examples

executor_example.cpp.

Definition at line 250 of file executor_example.cpp.

                                                                         {
    std::atomic<int> sum{0};
    std::vector<std::future<void>> futures;
 
    std::cout << "Processing " << data.size() << " items using "
              << executor.worker_count() << " workers\n";
 
    // Submit tasks using job-based API
    for (int value : data) {
        auto job = std::make_unique<function_job>([&sum, value] {
            // Simulate some work
            std::this_thread::sleep_for(10ms);
            sum += value * value;
        });
 
        auto result = executor.execute(std::move(job));
        if (result.is_ok()) {
            futures.push_back(std::move(result.value()));
        }
    }
 
    // Wait for completion
    for (auto& future : futures) {
        future.wait();
    }
 
    std::cout << "Sum of squares: " << sum << "\n";
}

References kcenon::common::interfaces::IExecutor::execute(), and kcenon::common::interfaces::IExecutor::worker_count().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: