Dynamic Asynchronous Tasking with Dependencies
Dynamic Task Graph Programming in Taskflow
Standard C++ provides std::async for launching asynchronous tasks, but its use in building complex parallel applications is severely limited by the lack of native support for task dependencies. In practice, many real-world parallel applications, such as those in scientific computing, data processing, gaming, trading, and electronic design automation, rely on tasks that depend on the completion of others. Without an explicit way to express these task dependencies, developers are often forced to manage synchronization manually or rely on custom partitioning, which introduces unnecessary complexity and hampers performance.
To overcome this challenge, this talk introduces a modern C++ programming model called AsyncTask, designed to support dynamic asynchronous tasking with dependencies. Unlike traditional construct-and-run models, AsyncTask enables developers to create and schedule tasks on-the-fly during execution, while explicitly specifying dependencies to ensure correct synchronization. This flexibility makes AsyncTask well-suited for parallelizing complex algorithms such as branch-and-bound search, adaptive pruning, and recursive decomposition, where the task graph evolves dynamically at runtime. To support the model with high performance, we introduce a work-stealing algorithm optimized for low latency, high throughput, and energy efficiency. The algorithm leverages C++20’s atomic_wait to significantly reduce synchronization overhead and improve scheduling efficiency. We believe that many of the design principles behind AsyncTask can inspire enhancements in future high-performance C++ tasking libraries by rethinking how we express dynamic task parallelism and dependencies through simpler and more flexible interfaces.
To demonstrate the real-world impact, we will showcase how AsyncTask has been applied to parallelize a VLSI static timing analysis workload. We will compare its performance against existing tasking libraries such as OpenMP and TBB, and highlight how AsyncTask achieves significant speedups when analyzing large designs with millions of tasks and dependencies. By the end of the talk, developers interested in modern C++ concurrency will come away with practical techniques for improving performance through dynamic task parallelism and dependency-aware scheduling. AsyncTask is fully integrated into the open-source Taskflow library, making it readily accessible to the broader C++ community.
Tsung-Wei (TW) Huang
Dr. Huang is an Associate Professor in ECE at the University of Wisconsin-Madison (UW-Madison), with an affiliate appointment in CS. Previously, he was an Assistant Professor at UW-Madison (2023–2025) and University of Utah (2019–2023). He earned his PhD in ECE from UIUC (2017) and BS/MS in CS from Taiwan’s NCKU (2011). His research focuses on building software systems for performance-critical applications, including CAD, machine learning, and quantum computing. His tools, such as Taskflow and OpenTimer, are widely used in industry and academia.
Dr. Huang has received several awards, including ACM SIGDA Outstanding PhD Dissertation Award, NSF CAREER Award, Humboldt Research Fellowship, ACM SIGDA Outstanding New Faculty Award, ICCAD 10-Year Most Influential Paper Award (OpenTimer), DAC Under-40 Innovator Award, and Vilas Early-career Investigator Award. Beyond research, he is passionate about software performance and has won top 3 in multiple programming contests, such as ACM SIGDA CADathlon, TAU Timing Contest, IEEE HPEC Graph Challenge, ICCAD CAD Contest, and ACM PPoPP FCPC. Dr. Huang has served on the TPC in DAC, ICCAD, MICRO, ASPLOS, HPCA, SC, IPDPS, etc.