taskflow/taskflow
Taskflow
Taskflow is a C++ task-parallel framework designed to build high-performance parallel workflows and complex dependency graphs. It provides a programming model that organizes computational work into directed acyclic graphs, enabling developers to manage concurrency, resource scheduling, and task dependencies across multi-core CPUs and GPU accelerators.
The framework distinguishes itself through its ability to orchestrate heterogeneous systems, allowing for the integration of hardware-accelerated kernels and memory operations into unified execution pipelines. It supports dynamic runtime subflows, which permit the spawning of new tasks during execution to handle unpredictable or recursive workloads, and offers modular composition to nest sub-graphs within larger, reusable structures.
Beyond core scheduling, the project includes a comprehensive suite of parallel algorithms for data processing, such as sorting, reduction, and prefix sums. It also features robust pipeline orchestration for multi-stage data streaming, along with built-in diagnostic tools for profiling performance, monitoring execution progress, and visualizing task dependencies.
The library provides extensive infrastructure for managing graphics hardware, including stream lifecycle management, event coordination, and cross-memory data transfers. It is implemented as a header-only C++ library, facilitating integration into existing high-performance computing environments.
Features
- C++ Task Engines - Provides a high-performance framework for composing asynchronous tasks into parallel workflows in C++.
- Directed Acyclic Graph Engines - Organizes computational work into directed acyclic graphs to manage task dependencies and execution order across multi-core CPUs and GPUs.
- Task-Based Concurrency Frameworks - Organizes computational work into directed acyclic graphs to manage concurrency, dependencies, and resource scheduling.
- Heterogeneous Workflow Orchestrators - Integrates hardware-accelerated kernels and memory operations into unified, heterogeneous parallel execution pipelines.
- GPU Acceleration - Offloads intensive data processing to graphics hardware by orchestrating kernels, memory operations, and streams within a unified framework.
- High-Performance and Parallel Computing - Builds high-performance applications that distribute computational workloads across multiple CPU cores using task-based dependency graphs.
- Data Processing Pipelines - Builds multi-stage processing workflows where data flows through sequential or parallel stages to maximize throughput.
- Dynamic Task Spawning - Supports spawning new tasks during execution to handle recursive or unpredictable workloads.
- Heterogeneous Orchestrators - Integrates device-specific compute kernels into host-side task graphs to enable unified execution across CPUs and graphics accelerators.
- Declarative Pipeline Construction - Builds multi-stage data processing pipelines where stages execute either serially or in parallel to transform data.
- Parallel Work Partitioning - Configures how computational workloads are divided among threads to optimize parallel execution.
- Task Dependencies - Establishes execution order between hardware-accelerated tasks by creating precedence links that ensure specific tasks complete before others begin.
- Task Graph Definition - Enables the construction of complex execution sequences for graphics hardware by chaining memory operations, computational kernels, and specific algorithmic tasks.
- Parallel Algorithms - Provides a comprehensive suite of parallel algorithms for data processing, such as sorting, reduction, and prefix sums.
- Recursive Subflow Generators - Enables recursive parallelism by spawning sub-graphs dynamically during execution.
- Modular Program Composition - Enables grouping independent task graphs into modular units for complex workflow composition.
- Subflow Orchestrators - Supports recursive and unpredictable workload generation by allowing tasks to spawn additional parallel work during active execution.
- Work-Stealing Queues - Allocates work-stealing queues to store and distribute parallel tasks across multiple threads for efficient load balancing.
- Host-Device Synchronization - Supports running CPU-side functions within graphics hardware task graphs to handle non-device operations.
- Kernel Dispatchers - Manages the dispatch of computational tasks to graphics hardware by coordinating graph-based execution flows.
- Concurrency and Parallelism - General-purpose parallel and heterogeneous task programming system.
- Concurrency Libraries - Modern parallel task programming framework.
- Parallel Programming Frameworks - Modern C++ library for parallel task programming.
- Data Processing Pipelines - Constructs multi-stage processing workflows where data flows through concurrent stages to maximize throughput in data-intensive applications.
- Stream and Pipeline Orchestration - Orchestrates multi-stage processing by flowing data tokens through sequential or parallel stages to maximize throughput.
- Parallel Execution Profilers - Monitors and analyzes the performance of task-based programs to identify bottlenecks and optimize work distribution.
- Pipeline Execution Engines - Manages the lifecycle and state of data processing pipelines, including resetting or running tasks until specific conditions are met.
- Task Composition Engines - Enables the construction of complex workflows by nesting modular sub-graphs and pipelines within larger, reusable task structures.
- Work-Stealing Schedulers - Balances computational load dynamically by allowing idle worker threads to claim pending tasks from the queues of busy threads.
- Concurrent Task Limiters - Limits task execution by requiring the acquisition of a specified range of semaphores to manage concurrency levels.
- Execution Flow Control - Integrates conditional logic into task graphs to enable branching and cycles during execution.
- Taskflow Cancellation Handlers - Allows stopping pending tasks while permitting currently running tasks to finish.
- Stream Event Synchronizers - Records events on a stream or forces a stream to wait for the completion of specific events to manage task dependencies.
- Parallel Data Reducers - Aggregates elements from a collection into a single result using parallel reduction patterns within a task graph.
- Parallel Data Merging - Combines two sorted sequences into a single sorted sequence using parallel processing to improve throughput.
- Pipeline Execution Monitors - Queries runtime statistics of scheduling tokens during pipeline processing to track progress and identify stage, line, and token numbers.
- Task Dependency Managers - Queries task dependencies to analyze the structure of parallel execution graphs.
- Operation Capture Engines - Records sequences of stream operations into a graph structure for later execution, supporting multiple thread-safety modes.
- Cross-Memory Transfer Utilities - Copies data blocks between CPU and hardware accelerator memory locations using typed or byte-level operations.
- Parallel Prefix Sum Calculators - Computes the cumulative sum of a range of elements across multiple threads to aggregate data efficiently.
- Parallel - Organizes collections of data using multi-threaded sorting algorithms that leverage task-parallel infrastructure.
- Subflow Lifecycle Monitoring - Provides methods to verify subflow execution status to manage task lifecycles.
- Execution Progress Trackers - Observes the state and performance of task execution through custom observers to track progress and identify bottlenecks.
- Stream Lifecycle Managers - Encapsulates stream resources with unique ownership to ensure proper creation and destruction of stream handles and associated events.
- Memory Object Pools - Recycles memory resources through a dedicated pool to minimize allocation overhead during high-frequency task cycles.
- Host Memory Accessors - Provides mechanisms to retrieve memory addresses associated with graphics hardware structures to coordinate data movement.
- Placeholder Task Nodes - Reserves nodes in a task graph without assigning work to allow for dynamic task assignment.
- Task Dependency Visualizers - Exports the structure of a task graph into a standard format to allow for graphical inspection and debugging.
