async_executor_demo.cpp File Reference

High-performance async_executor with thread_system integration. More...

#include <iostream>
#include <chrono>
#include <vector>
#include "database/async/async_operations.h"

Include dependency graph for async_executor_demo.cpp:

Go to the source code of this file.

Functions
void	demonstrate_basic_usage ()
void	demonstrate_high_throughput ()
void	demonstrate_error_handling ()
void	demonstrate_shutdown ()
void	compare_with_legacy ()
int	main ()

Detailed Description

High-performance async_executor with thread_system integration.

Definition in file async_executor_demo.cpp.

Function Documentation

compare_with_legacy()

void compare_with_legacy

(

)

Examples

async_executor_demo.cpp.

Definition at line 158 of file async_executor_demo.cpp.

                           {
    std::cout << "=== Performance Comparison ===\n";
    std::cout << "async_executor vs std::async\n\n";
 
    const int num_tasks = 1000;
 
    // Test async_executor
    {
        async_executor executor(8);
        auto start = high_resolution_clock::now();
 
        std::vector<std::future<int>> futures;
        for (int i = 0; i < num_tasks; ++i) {
            futures.push_back(executor.submit([i]() { return i * 2; }));
        }
 
        for (auto& f : futures) {
            f.get();
        }
 
        auto end = high_resolution_clock::now();
        auto duration = duration_cast<microseconds>(end - start);
 
        std::cout << "async_executor: " << duration.count() << " μs\n";
        std::cout << "  (" << (duration.count() / num_tasks) << " μs/task)\n";
    }
 
    // Test std::async
    {
        auto start = high_resolution_clock::now();
 
        std::vector<std::future<int>> futures;
        for (int i = 0; i < num_tasks; ++i) {
            futures.push_back(std::async(std::launch::async, [i]() { return i * 2; }));
        }
 
        for (auto& f : futures) {
            f.get();
        }
 
        auto end = high_resolution_clock::now();
        auto duration = duration_cast<microseconds>(end - start);
 
        std::cout << "std::async:        " << duration.count() << " μs\n";
        std::cout << "  (" << (duration.count() / num_tasks) << " μs/task)\n";
    }
 
    std::cout << "\n";
}

References database::async::async_executor::submit().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demonstrate_basic_usage()

void demonstrate_basic_usage

(

)

Examples

async_executor_demo.cpp.

Definition at line 29 of file async_executor_demo.cpp.

                               {
    std::cout << "=== Basic async_executor Usage ===\n";
 
    // Create executor with default thread count
    async_executor executor;
 
    std::cout << "Executor created with " << executor.thread_count() << " threads\n";
    std::cout << "Using thread_system: " << (executor.is_using_thread_system() ? "YES" : "NO") << "\n\n";
 
    // Submit simple tasks
    std::cout << "Submitting 5 simple tasks...\n";
    std::vector<std::future<int>> futures;
 
    auto start = high_resolution_clock::now();
 
    for (int i = 0; i < 5; ++i) {
        auto future = executor.submit([i]() {
            // Simulate some work
            std::this_thread::sleep_for(milliseconds(100));
            return i * i;
        });
        futures.push_back(std::move(future));
    }
 
    // Collect results
    std::cout << "Collecting results:\n";
    for (size_t i = 0; i < futures.size(); ++i) {
        int result = futures[i].get();
        std::cout << "  Task " << i << " result: " << result << "\n";
    }
 
    auto end = high_resolution_clock::now();
    auto duration = duration_cast<milliseconds>(end - start);
 
    std::cout << "Total time: " << duration.count() << "ms\n";
    std::cout << "(Expected ~100ms with concurrent execution)\n\n";
}

References database::async::async_executor::is_using_thread_system(), database::async::async_executor::submit(), and database::async::async_executor::thread_count().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demonstrate_error_handling()

void demonstrate_error_handling

(

)

Examples

async_executor_demo.cpp.

Definition at line 107 of file async_executor_demo.cpp.

                                  {
    std::cout << "=== Error Handling ===\n";
 
    async_executor executor(4);
 
    // Submit task that throws exception
    auto future = executor.submit([]() -> int {
        throw std::runtime_error("Simulated error in task");
        return 42;
    });
 
    try {
        int result = future.get();
        std::cout << "Result: " << result << "\n";
    } catch (const std::exception& e) {
        std::cout << "✅ Caught exception: " << e.what() << "\n";
    }
 
    std::cout << "\n";
}

References database::async::async_executor::submit().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demonstrate_high_throughput()

void demonstrate_high_throughput

(

)

Examples

async_executor_demo.cpp.

Definition at line 67 of file async_executor_demo.cpp.

                                   {
    std::cout << "=== High-Throughput Performance Test ===\n";
 
    async_executor executor(8);
 
    const int num_tasks = 10000;
    std::cout << "Submitting " << num_tasks << " lightweight tasks...\n";
 
    auto start = high_resolution_clock::now();
 
    std::vector<std::future<int>> futures;
    futures.reserve(num_tasks);
 
    for (int i = 0; i < num_tasks; ++i) {
        futures.push_back(executor.submit([i]() {
            // Very lightweight task
            return i * 2;
        }));
    }
 
    // Wait for completion
    executor.wait_for_completion();
 
    auto end = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(end - start);
 
    std::cout << "Submitted " << num_tasks << " tasks in "
              << duration.count() << " microseconds\n";
    std::cout << "Average latency: "
              << (duration.count() / num_tasks) << " microseconds/task\n";
 
    if (executor.is_using_thread_system()) {
        std::cout << "✅ thread_system: Expected ~77ns latency per task\n";
    } else {
        std::cout << "⚠️  Fallback mode: Expected ~2-5μs latency per task\n";
    }
 
    std::cout << "\n";
}

References database::async::async_executor::is_using_thread_system(), database::async::async_executor::submit(), and database::async::async_executor::wait_for_completion().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demonstrate_shutdown()

void demonstrate_shutdown

(

)

Examples

async_executor_demo.cpp.

Definition at line 128 of file async_executor_demo.cpp.

                            {
    std::cout << "=== Graceful Shutdown ===\n";
 
    async_executor executor(4);
 
    // Submit long-running tasks
    std::cout << "Submitting 3 long-running tasks...\n";
    std::vector<std::future<void>> futures;
 
    for (int i = 0; i < 3; ++i) {
        futures.push_back(executor.submit([i]() {
            std::cout << "  Task " << i << " starting...\n";
            std::this_thread::sleep_for(milliseconds(200));
            std::cout << "  Task " << i << " completed\n";
        }));
    }
 
    std::cout << "Pending tasks: " << executor.pending_tasks() << "\n";
 
    // Wait for completion
    std::cout << "Waiting for tasks to complete...\n";
    for (auto& future : futures) {
        future.get();
    }
 
    std::cout << "✅ All tasks completed, shutting down...\n";
    executor.shutdown();
    std::cout << "✅ Executor shut down gracefully\n\n";
}

References database::async::async_executor::pending_tasks(), database::async::async_executor::shutdown(), and database::async::async_executor::submit().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 208 of file async_executor_demo.cpp.

           {
    std::cout << "╔════════════════════════════════════════════════╗\n";
    std::cout << "║  async_executor Demonstration              ║\n";
    std::cout << "║  thread_system Integration for Database       ║\n";
    std::cout << "╚════════════════════════════════════════════════╝\n\n";
 
    try {
        demonstrate_basic_usage();
        demonstrate_high_throughput();
        demonstrate_error_handling();
        demonstrate_shutdown();
        compare_with_legacy();
 
        std::cout << "╔════════════════════════════════════════════════╗\n";
        std::cout << "║  ✅ All demonstrations completed successfully ║\n";
        std::cout << "╚════════════════════════════════════════════════╝\n";
 
        return 0;
    }
    catch (const std::exception& e) {
        std::cerr << "❌ Error: " << e.what() << "\n";
        return 1;
    }
}

References compare_with_legacy(), demonstrate_basic_usage(), demonstrate_error_handling(), demonstrate_high_throughput(), and demonstrate_shutdown().

Here is the call graph for this function: