Comprehensive ThreadPool Usage Examples: Parallel Task Execution. More...

#include <thread_pool.H>
#include <concurrency_utils.H>
#include <ah-errors.H>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdexcept>
#include <cmath>
#include <chrono>
#include <fstream>
#include <sstream>

Include dependency graph for thread_pool_example.cc:

Classes
struct	FileResult

Functions
void	print_header (const std::string &title)

bool	is_prime (int n)

void	example_basic_parallel ()

FileResult	process_file (const std::string &filename)

void	example_batch_processing ()

void	example_fire_and_forget ()

void	example_backpressure ()

void	example_load_shedding ()

void	example_structured_concurrency ()

void	example_parallel_building_blocks ()

void	example_channels_and_shared_state ()

void	example_performance ()

int	main ()

Detailed Description

Comprehensive ThreadPool Usage Examples: Parallel Task Execution.

This file demonstrates how to use the ThreadPool class effectively for parallel task execution. ThreadPool provides a high-level interface for managing worker threads and executing tasks concurrently, making it easier to parallelize computations.

What is a Thread Pool?

A thread pool is a collection of worker threads that execute tasks from a queue. Instead of creating threads for each task, threads are reused, reducing overhead and improving performance.

Benefits:

Reduced overhead: Reuse threads instead of creating/destroying
Resource control: Limit number of concurrent threads
Task queuing: Handle more tasks than threads
Load balancing: Distribute work across threads

Features Demonstrated

Example 1: Basic Parallel Computation

**enqueue()**: Submit task and get future
Futures: Wait for results asynchronously
Basic pattern: Most common usage

Example 2: Batch Processing

**enqueue_bulk()**: Process collections in parallel
Batch operations: Efficient parallel processing
Collection handling: Work with containers

Example 3: Fire-and-Forget Tasks

**enqueue_detached()**: Submit without waiting
Async operations: Don't need results
Background tasks: Long-running operations

Example 4: Backpressure Control

**enqueue_bounded()**: Limit queue size
Flow control: Prevent queue overflow
Backpressure: Handle overload gracefully

Example 5: Non-Blocking Submission

**try_enqueue()**: Submit without blocking
Load shedding: Reject when overloaded
Non-blocking: Don't wait if queue full

Example 6: Structured Tasks and Cooperative Cancellation

**TaskGroup**: launch related tasks and wait as a unit
**CancellationSource / CancellationToken**: cooperative stop requests
Structured concurrency: exceptions propagate from wait()

Example 7: Foundational Parallel Building Blocks

**parallel_invoke()**: launch a small related set of tasks
**pscan() / pexclusive_scan()**: prefix sums in parallel
**pmerge()**: merge sorted ranges with the same pool/options machinery

Example 8: Channels and Synchronized Shared State

**bounded_channel<T>**: bounded producer-consumer handoff with close
**synchronized<T>**: mutex-protected shared objects
**rw_synchronized<T>**: read/write-lock protected shared objects
**spsc_queue<T>**: bounded single-producer/single-consumer handoff

Example 9: Performance Comparison

Benchmarking: Compare parallel vs sequential
Speedup: Measure performance gains
Scalability: Test with different thread counts

Quick Start

// Create thread pool with 4 worker threads
ThreadPool pool(4);
 
// Submit a task and get a future
auto future = pool.enqueue([](int x) { return x * x; }, 5);
 
// Wait for result
int result = future.get();  // result = 25

When to Use ThreadPool

✅ Good for:

CPU-intensive tasks
Independent computations
Batch processing
Parallel algorithms

❌ Not good for:

I/O-bound tasks (use async I/O)
Very short tasks (overhead too high)
Tasks with dependencies (use task graphs)

Complexity

Operation	Complexity	Notes
enqueue()	O(1) amortized	Queue insertion
Future.get()	O(1)	Wait for completion
Thread creation	O(1)	Done at pool creation

Performance Considerations

Thread count: Usually CPU cores - 1 or CPU cores
Task granularity: Tasks should be substantial (avoid tiny tasks)
Overhead: ThreadPool has overhead, measure before optimizing
Cache effects: Consider data locality

Usage

./thread_pool_example

This example has no command-line options; it runs all examples.

Compilation

g++ -std=c++20 -O2 -pthread -I.. thread_pool_example.cc -o thread_pool_example

Or using CMake:

cmake --build . --target thread_pool_example

See also: thread_pool.H ThreadPool class implementation; ah_parallel_example.cc Parallel functional programming (uses ThreadPool)

Author: Leandro Rabindranath León

Definition in file thread_pool_example.cc.

Function Documentation

◆ example_backpressure()

void example_backpressure ( )

Definition at line 390 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), Aleph::ThreadPool::enqueue_bounded_detached(), Aleph::ThreadPool::get_queue_limits(), Aleph::ThreadPool::pending_tasks(), print_header(), Aleph::ThreadPool::set_queue_limits(), and Aleph::ThreadPool::wait_all().

Referenced by main().

◆ example_basic_parallel()

void example_basic_parallel ( )

Definition at line 190 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), Aleph::ThreadPool::enqueue(), is_prime(), Aleph::ThreadPool::num_threads(), and print_header().

Referenced by main().

◆ example_batch_processing()

void example_batch_processing ( )

Definition at line 280 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), Aleph::ThreadPool::enqueue_bulk(), Aleph::ThreadPool::num_threads(), print_header(), and process_file().

Referenced by main().

◆ example_channels_and_shared_state()

void example_channels_and_shared_state ( )

Definition at line 623 of file thread_pool_example.cc.

References Aleph::count(), Aleph::divide_and_conquer_partition_dp(), and print_header().

Referenced by main().

◆ example_fire_and_forget()

void example_fire_and_forget ( )

Definition at line 344 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), Aleph::ThreadPool::enqueue_detached(), print_header(), and Aleph::ThreadPool::wait_all().

Referenced by main().

◆ example_load_shedding()

void example_load_shedding ( )

Definition at line 468 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), print_header(), Aleph::ThreadPool::set_queue_limits(), Aleph::ThreadPool::try_enqueue_detached(), and Aleph::ThreadPool::wait_all().

Referenced by main().

◆ example_parallel_building_blocks()

void example_parallel_building_blocks ( )

Definition at line 568 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), options, Aleph::parallel_invoke(), Aleph::pexclusive_scan(), Aleph::pmerge(), Aleph::ParallelOptions::pool, print_header(), Aleph::product(), Aleph::pscan(), seed, and Aleph::sum().

Referenced by main().

◆ example_performance()

void example_performance ( )

Definition at line 698 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp(), Aleph::ThreadPool::enqueue(), Aleph::ThreadPool::num_threads(), and print_header().

Referenced by main().

◆ example_structured_concurrency()

void example_structured_concurrency ( )

Definition at line 518 of file thread_pool_example.cc.

References ah_runtime_error, Aleph::completed(), Aleph::divide_and_conquer_partition_dp(), print_header(), and Aleph::CancellationSource::token().

Referenced by main().

◆ is_prime()

bool is_prime ( int n )

Definition at line 180 of file thread_pool_example.cc.

Referenced by example_basic_parallel(), and example_parallel_filter().

◆ main()

int main ( )

Definition at line 765 of file thread_pool_example.cc.

References example_backpressure(), example_basic_parallel(), example_batch_processing(), example_channels_and_shared_state(), example_fire_and_forget(), example_load_shedding(), example_parallel_building_blocks(), example_performance(), and example_structured_concurrency().

◆ print_header()

void print_header ( const std::string & title )

Definition at line 155 of file thread_pool_example.cc.

◆ process_file()

FileResult process_file ( const std::string & filename )

Definition at line 266 of file thread_pool_example.cc.

References Aleph::divide_and_conquer_partition_dp().

Referenced by example_batch_processing().

Classes

Functions

Detailed Description

What is a Thread Pool?

Features Demonstrated

Example 1: Basic Parallel Computation

Example 2: Batch Processing

Example 3: Fire-and-Forget Tasks

Example 4: Backpressure Control

Example 5: Non-Blocking Submission

Example 6: Structured Tasks and Cooperative Cancellation

Example 7: Foundational Parallel Building Blocks

Example 8: Channels and Synchronized Shared State

Example 9: Performance Comparison

Quick Start

When to Use ThreadPool

Complexity

Performance Considerations

Usage

Compilation

Function Documentation

◆ example_backpressure()

◆ example_basic_parallel()

◆ example_batch_processing()

◆ example_channels_and_shared_state()

◆ example_fire_and_forget()

◆ example_load_shedding()

◆ example_parallel_building_blocks()

◆ example_performance()

◆ example_structured_concurrency()

◆ is_prime()

◆ main()

◆ print_header()

◆ process_file()