Task-Based Parallelism Frameworks — Task-based parallelism expresses parallel computation as a collection of tasks with dependencies rather than explicit thread management, enabling runtime systems to dynamically schedule work across available processors for improved load balancing and composability.

Task-Based Programming Model — The fundamental abstraction shifts from threads to tasks:

• Task Creation — programmers define units of work as tasks that can execute independently or with explicit dependency constraints, without specifying which thread or processor executes them
• Dependency Specification — tasks declare their data dependencies or ordering constraints, forming a directed acyclic graph that the runtime uses to determine safe parallel execution order
• Dynamic Granularity — tasks can recursively spawn child tasks, allowing the decomposition granularity to adapt to the problem structure rather than being fixed at compile time
• Implicit Synchronization — the runtime automatically enforces dependency constraints, eliminating the need for explicit locks, barriers, or condition variables in most cases

OpenMP Task Directives — The widely-used standard provides task-based extensions:

• Task Pragma — the #pragma omp task directive creates a new task from a code block, with the runtime scheduling it for execution on any available thread in the team
• Taskwait Synchronization — the taskwait directive suspends the current task until all its direct child tasks complete, providing structured synchronization without explicit barriers
• Task Dependencies — the depend clause specifies input, output, and inout dependencies between tasks, enabling the runtime to build and execute a task dependency graph automatically
• Taskloop Construct — combines task creation with loop iteration distribution, automatically chunking loop iterations into tasks for dynamic load balancing

Intel Threading Building Blocks — A C++ template library for task parallelism:

• Flow Graph — TBB's flow graph API defines computation as a network of nodes connected by edges, with data flowing through the graph and triggering node execution automatically
• Parallel Algorithms — high-level templates like parallel_for, parallel_reduce, and parallel_pipeline express common patterns without explicit task management
• Task Scheduler — TBB's work-stealing scheduler dynamically distributes tasks across worker threads, automatically balancing load without programmer intervention
• Task Arena — isolates groups of tasks into separate scheduling domains, preventing interference between independent parallel regions and enabling nested parallelism control

Cilk and Modern Task Runtimes — Pioneering and contemporary approaches:

• Cilk Spawn and Sync — the minimalist cilk_spawn keyword creates a task from a function call, and cilk_sync waits for all spawned tasks, providing elegant recursive parallelism
• Provable Guarantees — Cilk's work-stealing scheduler provides theoretical bounds on space usage and execution time relative to the sequential program
• C++ Executors — the emerging C++ standard executor model provides a unified interface for submitting tasks to different execution contexts including thread pools and GPU devices
• Rust Tokio and Rayon — Rust's ecosystem provides both asynchronous task runtimes for I/O-bound work and data-parallel frameworks for compute-bound tasks with memory safety guarantees

Task-based parallelism frameworks have become the preferred approach for expressing irregular and dynamic parallelism, offering superior composability and load balancing compared to traditional thread-based programming models.