Hierarchical scheduling and affinity-aware policies for task-based runtimes
In high-performance computing, the choice between the fork-join and tasking parallel programming models reflects a trade-off between simplicity and flexibility. The fork-join model is conceptually simple and has very low runtime overhead. It is particularly well suited for applications with evenly d...
| Autor: | |
|---|---|
| Tipo de recurso: | tesis de maestría |
| Fecha de publicación: | 2025 |
| País: | España |
| Institución: | Universitat Politècnica de Catalunya (UPC) |
| Repositorio: | UPCommons. Portal del coneixement obert de la UPC |
| Idioma: | inglés |
| OAI Identifier: | oai:upcommons.upc.edu:2117/449497 |
| Acceso en línea: | https://hdl.handle.net/2117/449497 |
| Access Level: | acceso abierto |
| Palabra clave: | High performance computing Parallel programming (Computer science) Computer scheduling OpenMP OMPSS-2 Programació de tasques HPC Afinitat Programació de diverses polítiques Models de programació paral·lel Task scheduling Task-based parallel computing Parallel programming models Hierarchical scheduling Càlcul intensiu (Informàtica) Programació en paral·lel (Informàtica) Planificació de tasques (Informàtica) Àrees temàtiques de la UPC::Informàtica::Programació |
| Sumario: | In high-performance computing, the choice between the fork-join and tasking parallel programming models reflects a trade-off between simplicity and flexibility. The fork-join model is conceptually simple and has very low runtime overhead. It is particularly well suited for applications with evenly distributed workloads and large parallel regions. Moreover, it naturally preserves temporal and spatial locality, since threads often work on contiguous data within well-defined regions, which aligns well with cache hierarchies in modern multi-core systems. However, this model can suffer from load imbalance within parallel regions and is fundamentally constrained by Amdahl's law, which limits overall speedup due to sequential parts of the code. In contrast, the tasking model offers greater flexibility: different computational phases can be overlapped, and load balancing is automatically managed by the runtime. This flexibility, however, comes at the cost of higher scheduling overhead, especially when tasks are too fine-grained, and it can degrade temporal and spatial locality, which are critical for achieving high performance on modern architectures. A core element of tasking models is the scheduling policy. Most modern task-based runtimes may offer users the ability to select from common scheduling strategies, such as FIFO, LIFO, or priority-based scheduling. While this configurability is useful, it often proves insufficient for complex applications running on hardware with deep memory and core hierarchies. For example, an application may benefit from different scheduling policies in different phases or computational kernels, depending on their behavior and resource needs. However, current systems typically apply a single, global policy, offering no mechanism to assign or compose policies per task group, which limits expressiveness and performance tuning. This work proposes a hierarchical scheduling infrastructure using taskgroups, where each can define its own scheduling policy. Taskgroups form tree-like hierarchies containing tasks or nested taskgroups. The scheduler recursively descends from the root to select tasks, enabling fine-grained control over execution order and locality-aware policies optimized for multi-core and NUMA systems, which is essential for achieving the desired performance on modern multi-core and NUMA systems. The aim is to allow the user to model the execution order of tasks to improve performance by exploiting application-specific execution patterns. This hierarchical and locality-aware approach offers a powerful mechanism to customize and optimize task execution for complex applications. |
|---|