Search

Task-based programming models are a promising approach to exploiting complex distributed and heterogeneous systems. However, integrating different communication, offloading, and storage APIs within tasks poses performance and deadlock risks. Several Task-Aware libraries, such as TAMPI, TASIO, and TACUDA, have been developed to integrate blocking and non-blocking APIs within task-based programming models efficiently. In this paper, we introduce the Asynchronous Low-level Programming Interface (ALPI) to enable the interoperability and portability of Task-Aware libraries across various programming models and runtime systems. We have implemented ALPI in the Nanos6 and nOS-V runtimes, enhancing the integration of Task-Aware libraries with the OmpSs-2 and OpenMP programming models. This work is a step towards improving the composability of parallel programming models by supporting Task-Aware libraries across different runtime systems., This work was supported by the Spanish Ministry of Science and Innovation (grant PID2019-107255GB) and the Severo Ochoa Program (grant CEX2021-001148-S), both funded by MCIN/AEI/10.13039/501100011033. The Generalitat de Catalunya also supported this work via grant 2021-SGR-01007., Peer Reviewed, Postprint (author's final draft)

Processors with multiple sockets or chiplets are becoming more conventional. These kinds of processors usually expose a single shared address space. However, due to hardware restrictions, they adopt a NUMA approach, where each processor accesses local memory faster than remote memories. Reducing data motion is crucial to improve the overall performance. Thus, computations must run as close as possible to where the data resides. We propose a new approach that mitigates the NUMA effect on NUMA systems. Our solution is based on the OmpSs-2 programming model, a task-based parallel programming model, similar to OpenMP. We first provide a simple API to allocate memory in NUMA systems using different policies. Then, combining user-given information that specifies dependences between tasks, and information collected in a global directory when allocating data, we extend our runtime library to perform NUMA-aware work scheduling. Our heuristic considers data location, distance between NUMA nodes, and the load of each NUMA node to seamlessly minimize data motion costs and load imbalance. Our evaluation shows that our NUMA support can significantly mitigate the NUMA effect by reducing the amount of remote accesses, and so improving performance on most benchmarks, reaching up to 2x speedup in a 2-NUMA machine, and up to 7.1x in a 8-NUMA machine., This research has received funding from the European Union’s Horizon 2020/EuroHPC research and innovation programme under grant agreement No 955606 (DEEP-SEA), project PCI2021121958 financed by the Spanish State Research Agency - Ministry of Science and Innovation, Generalitat de Catalunya (contract 2021-SGR-01007), the Spanish Ministry of Science and Technology (contract PID2019-107255GB), and Severo Ochoa (CEX2021- 001148-S / MCIN/AEI /10.13039/501100011033)., Peer Reviewed, Postprint (author's final draft)

The general matrix-matrix multiplication (GEMM) kernel is a fundamental building block of many scientific applications. Many libraries such as Intel MKL and BLIS provide highly optimized sequential and parallel versions of this kernel. The parallel implementations of the GEMM kernel rely on the well-known fork-join execution model to exploit multi-core systems efficiently. However, these implementations are not well suited for task-based applications as they break the data-flow execution model. In this paper, we present a task-based implementation of the GEMM kernel that can be seamlessly leveraged by task-based applications while providing better performance than the fork-join version. Our implementation leverages several advanced features of the OmpSs-2 programming model and a new heuristic to select the best parallelization strategy and blocking parameters based on the matrix and hardware characteristics. When evaluating the performance and energy consumption on two modern multi-core systems, we show that our implementations provide significant performance improvements over an optimized OpenMP fork-join implementation, and can beat vendor implementations of the GEMM (e.g., Intel MKL and AMD AOCL). We also demonstrate that a real application can leverage our optimized task-based implementation to enhance performance., Peer Reviewed, Postprint (author's final draft)

Being on the verge of exascale performance has shifted the prioritization of performance in applications to the inclusion of power-performance efficiency as a primary objective in the High Performance Computing (HPC) community. Simultaneously, this has surfaced hardware and software efforts that employ techniques such as dynamic voltage and frequency scaling (DVFS) for core and uncore units or dynamic concurrency throttling (DCT) to exploit hardware resources efficiently, by saving energy while maintaining performance. These techniques are complementary, so they can be used together. However, employing them is not a straightforward task, as they have to be adjusted based on the workload, and it is even more complex to combine them properly. Thus, these techniques should be applied transparently by a runtime system, without relying on application developers. In this paper, we extend a task-based runtime system with an infrastructure that categorizes workloads based on their computational profile – memory-bounded, compute-bounded, or balanced. This categorization is done in an on-line manner and with a negligible overhead. With this additional information, we enhance the CPU-manager and scheduler of OmpSs-2, a task-based parallel programming model, to automatically combine DVFS and DCT techniques based on workloads. Moreover, we show that our heuristics transparently improve energy efficiency on average by 15% with no significant performance loss and either equal or surpass the energy efficiency of the best static configuration available., This research has received funding from the European Union’s Horizon 2020/EuroHPC research and innovation programme under grant agreement N.955606 (DEEP-SEA), and is supported by the Spanish State Research Agency - Ministry of Science and Innovation (contract PID2019-107255GB), and by the Generalitat de Catalunya (2017-SGR-1414). This work was also supported by Project HPC- EUROPA3, with the support of the EC Research Innovation Action under the H2020 Programme., Peer Reviewed, Postprint (author's final draft)

Computation has been pushed to the edge to decrease latency and alleviate the computational burden of the IoT applications in the cloud. However, the increasing processing demands of Edge Applications make necessary the employment of platforms that exploit thread-level parallelism (TLP). Yet, power and heat dissipation rise as TLP inadvertently increases or when parallelism is not cleverly exploited, which may be the result of the non-ideal use of a given PPI (Parallel Program Interface). Besides the common issues, such as the need for more robust power sources and better cooling, heat also adversely affects aging, accelerating phenomenons such as negative bias temperature instability (NBTI) and hot-carrier injection (HCI), which further reduces processor lifetime. Hence, considering that increasing the lifespan of an edge device is key, so the number of times the application set may execute until its end-of-life is maximized, we propose BALDER. It is a learning framework capable of automatically choosing optimal configuration executions (PPI and number of threads) according to the parallel application at hand, aiming to maximize the trade-off between aging and performance. When executing ten well-known applications on two multicore embedded architectures, we show that BALDER can find a nearly-optimal configuration for all our experiments., Peer Reviewed, Postprint (author's final draft)

Task-based programming models are emerging as a promising alternative to make the most of multi-/many-core systems. These programming models rely on runtime systems, and their goal is to improve application performance by properly scheduling application tasks to cores. Additionally, these runtime systems offer policies to cope with application phases that lack in parallelism to fill all cores. However, these policies are usually static and favor either performance or energy efficiency. In this paper, we have extended a task-based runtime system with a lightweight monitoring and prediction infrastructure that dynamically predicts the optimal number of cores required for each application phase, thus improving both performance and energy efficiency. Through the execution of several benchmarks in multi-/many-core systems, we show that our prediction-based policies have competitive performance while improving energy efficiency when compared to state of the art policies., This project is supported by the European Union’s Horizon 2021 research and innovation programme under the grant agreement No 754304 (DEEP-EST), the Ministry of Economy of Spain through the Severo Ochoa Center of Excellence Program (SEV-2015-0493), by the Spanish Ministry of Science and Innovation (contract TIN2015-65316-P) and by the Generalitat de Catalunya (2017-SGR1481). This work was also supported by Project HPC-EUROPA3 (INFRAIA2016-1-730897), with the support of the EC Research Innovation Action under the H2020 Programme., Peer Reviewed, Postprint (author's final draft)

Manually tuning applications to achieve optimal configurations prevails as the default technique. This raises issues, since these configurations depend on many aspects. To solve them, we propose extending runtimes with tools to obtain and predict metrics in order to enhance scheduling policies.

Després d’un breu resum sobre el model de programació OmpSs i els elements que formen el seu entorn, com és el runtime Nanos6 i el compilador Mercurium, aquest document mostra el desenvolupament portat a terme per dotar Nanos6 amb un mòdul de mesura per fer profiling de tasques, un mòdul de predicció i un mòdul anomenat autofinal que farà ús dels mòduls previs per incrementar el rendiment del runtime, així com el disseny i la implementació de tots aquests mòduls. Es començarà dissenyant el mòdul de mesura, definint tots els conceptes i característiques que és capaç d’obtenir d’execucions. Més endavant es modificaran el model i el runtime per tal de suportar noves clàusules com la clàusula cost. Després s’implementarà el mòdul de prediccions que s’alimentarà de les dades proveïdes pel mòdul de mesura i, per últim, el mòdul autofinal que farà ús explícit del mòdul de predicció però a la vegada farà ús implícit de tots els nous mòduls o clàusules dissenyats. Un cop finalitzada la part de disseny i implementació, s’avaluarà el rendiment del runtime extés amb diferents benchmarks, prèviament analitzant el temps afegit a causa de les modificacions fetes al runtime., After a brief about the OmpSs programming model and all the elements which create its environmennt, such as the Nanos6 runtime or the Mercurium compiler, this document will show the development of several modules in order to extend Nanos6 with a measurement module, a prediction module and an autofinal module which will use all of the previously mentioned modules. First the measurement module will be designed, while defining all the concepts and characteristics that it can extract from executions. After that, the model and runtime will be modified in order to support new clauses such as the cost clause. The implementation of the prediction module which accepts data provided by the measurement module will follow. Once the aforementioned modules are designed and implemented, the autofinal module will be implemented and it will use all the previous modules either implicitly or explicitly. Afterwards, a performance evaluation of the extended runtime will be done using different benchmarks, previously analyising the overhead added due to modifications to the runtime.