(English) Modern supercomputing systems feature thousands of computing nodes that already provide hundreds of cores. Parallelizing scientific and engineering applications to leverage all these resources has become a significant challenge for the HPC community. Any application that aims to perform well at scale must efficiently orchestrate and exploit both inter- and intra-node parallelism. Multiple programming models exist to exploit each of these parallelism classes. MPI and OpenMP are de facto standards for distributed- and shared-memory parallelism, respectively. MPI is a message-passing interface based on processes with separate virtual address spaces, while OpenMP defines thread-based and task-based interfaces for shared-memory parallelization. Applications can combine both types of programming models to take advantage of their particular benefits in a technique called hybrid parallel programming. Combining task-based and message-passing programming models is a promising hybrid approach that can provide a high-performance data-flow model without damaging the programmability of applications. An application can be represented as a set of directed acyclic graphs (DAGs) with one independent graph per process. Vertices represent tasks comprising computations and communications, edges represent the data dependencies among tasks, and the tasks from distinct processes (i.e., different DAGs) can communicate through message passing. This way, the intra- and inter-node parallelism is smoothly orchestrated through the task graphs. Moreover, this data-flow approach has other benefits: fine synchronizations through data dependencies and inter-process messages, the natural overlap and intertwining of application phases (e.g., computation and communication), and an automatic load balancing within each process. However, the current standards (e.g., MPI and OpenMP) prevent tasks from issuing communications efficiently, as severe performance and programmability issues must be tackled. This thesis designs and implements software solutions that allow task-based applications to efficiently incorporate communications inside their task graphs. We solve the well-known interoperability issues between task-based and message-passing programming models through two task-aware libraries. The two new libraries provide full support to application tasks that issue communications through task-aware communication operations, which can feature blocking or non-blocking semantics. The TAMPI library supports two-sided MPI communications (e.g., send/receive and collectives), and the TAGASPI library supports the one-sided communications (also known as RMA) provided by the GASPI interface. Furthermore, our task-aware mechanisms are generic enough to incorporate any other blocking or non-blocking interface (e.g., for GPU offloading) with task-based models. Our hybrid data-flow approach, which combines tasking and message passing, provides performance, scalability, and programmability for task-based applications on highly parallel systems. We demonstrate these benefits by porting several benchmarks and applications and comparing our approach with other state-of-the-art techniques.

(Català) Els sistemes de supercomputació moderns presenten milers de nodes de computació que ja arriben a proporcionar fins a centenars de nuclis cada un. Paral·lelitzar les aplicacions científiques i d'enginyeria per aprofitar tots aquests recursos s'ha convertit en un repte important per a la comunitat HPC. Qualsevol aplicació que pretengui escalar bé ha d'orquestrar i explotar eficientment els paral·lelismes d'inter-node i intra-node. Existeixen múltiples models de programació per explotar cadascuna d'aquestes classes de paral·lelisme. MPI i OpenMP són els estàndards de facto per al paral·lelisme de memòria distribuïda i compartida, respectivament. MPI és una interfície de pas de missatges basada en processos amb espais d'adreces virtuals separats, mentre que OpenMP defineix interfícies basades en fils i en tasques per a la paral·lelització en memòria compartida. Les aplicacions poden combinar ambdós tipus de models de programació per aprofitar els beneficis de cada un en una tècnica que s'anomena programació híbrida paral·lela. La combinació de models de programació basats en tasques i de pas de missatges és un enfocament híbrid prometedor que pot proporcionar un model de flux de dades d'alt rendiment sense empitjorar la programabilitat de les aplicacions. Una aplicació es pot representar com un conjunt de grafs acíclics dirigits (DAGs) amb un graf independent per procés. Els vèrtexs representen tasques que poden comprendre càlcul i/o comunicacions, les arestes representen les dependències de dades entre les tasques, i les tasques de diferents processos (és a dir, diferents DAGs) poden comunicar-se a través del pas de missatges. D'aquesta manera, el paral·lelisme intra- i inter-node s'orquestra fluidament a través dels grafs de tasques. A més, aquest enfocament de flux de dades té altres beneficis: les sincronitzacions fines a través de les dependències de dades i els missatges entre tasques de diferents processos, la superposició natural i l'entrellaçament de les fases de l'aplicació (p. ex., el càlcul i la comunicació), i un equilibri de càrrega automàtic dins de cada procés. No obstant això, els estàndards actuals (p. ex., MPI i OpenMP) impedeixen que les tasques puguin emetre comunicacions eficientment, donat que s'han d'abordar problemes greus de rendiment i programabilitat. Aquesta tesi se centra en el disseny i implementació de programari que permeti de manera eficient que les aplicacions basades en tasques incorporin comunicacions dins dels seus grafs de tasques. Resolem els problemes d'interoperabilitat entre els models de programació basats en tasques i de pas de missatges a través de dues biblioteques que són conscients de l'entorn de tasques. Aquestes dues noves biblioteques proporcionen suport complet a les tasques d'aplicacions que emeten comunicacions mitjançant noves operacions de comunicació que tenen en compte l'entorn de tasques, i que poden tenir semàntica bloquejant o no bloquejant. La biblioteca TAMPI suporta les comunicacions "two-sided" d'MPI (p. ex., enviar/rebre missatges), mentre que la biblioteca TAGASPI suporta les comunicacions "one-sided" (també conegudes com a RMA) proporcionades per la interfície GASPI. A més, els nostres mecanismes són prou genèrics per a incorporar qualsevol altra interfície bloquejant o no bloquejant (p. ex., per accelerar codi a través de GPU) en models basats en tasques. El nostre enfocament híbrid de flux de dades que combina tasques i pas de missatges proporciona rendiment, escalabilitat i programabilitat per a aplicacions en sistemes altament paral·lels. Demostrem aquests beneficis portant-hi diversos "benchmarks" i aplicacions, i comparant el nostre enfocament amb altres tècniques actuals.

(Español) Los sistemas de supercomputación modernos presentan miles de nodos de computación que ya llegan a proporcionar hasta centenares de núcleos cada uno. Paralelizar las aplicaciones científicas y de ingeniería para aprovechar todos estos recursos se ha convertido en un reto importante para la comunidad HPC. Cualquier aplicación que pretenda escalar bien tiene que orquestar y explotar eficientemente los paralelismos de inter-nodo e intra-nodo. Existen múltiples modelos de programación para explotar cada una de estas clases de paralelismo. MPI y OpenMP son los estándares de facto para el paralelismo de memoria distribuida y compartida, respectivamente. MPI es una interfaz de paso de mensajes basada en procesos con espacios de direcciones virtuales separados, mientras que OpenMP define interfaces basadas en hilos y en tareas para la paralelización en memoria compartida. Las aplicaciones pueden combinar ambos tipos de modelos de programación para aprovechar los beneficios de cada uno en una técnica que se denomina programación híbrida paralela. La combinación de modelos de programación basados en tareas y de paso de mensajes es un enfoque híbrido prometedor que puede proporcionar un modelo de flujo de datos de alto rendimiento sin empeorar la programabilidad de las aplicaciones. Una aplicación se puede representar como un conjunto de grafos acíclicos dirigidos (DAGs) con un grafo independiente por proceso. Los vértices representan tareas que pueden comprender cálculo y/o comunicaciones, las aristas representan las dependencias de datos entre las tareas, y las tareas de diferentes procesos (es decir, diferentes DAGs) pueden comunicarse a través del paso de mensajes. De este modo, el paralelismo intra- e inter-nodo se orquesta fluidamente a través de los grafos de tareas. Además, este enfoque de flujo de datos tiene otros beneficios: las sincronizaciones finas a través de las dependencias de datos y los mensajes entre tareas de diferentes procesos, la superposición natural y el entrelazado de las fases de la aplicación (p. ej., el cálculo y la comunicación), y un equilibrio de carga automático dentro de cada proceso. Sin embargo, los estándares actuales (p. ej., MPI y OpenMP) impiden que las tareas puedan emitir comunicaciones eficientemente, dado que se tienen que abordar problemas graves de rendimiento y programabilidad. Esta tesis se centra en el diseño e implementación de software que permita de manera eficiente que las aplicaciones basadas en tareas incorporen comunicaciones dentro de sus grafos de tareas. Resolvemos los problemas de interoperabilidad entre los modelos de programación basados en tareas y de paso de mensajes a través de dos bibliotecas que son conscientes del entorno de tareas. Estas dos nuevas bibliotecas proporcionan apoyo completo a las tareas de aplicaciones que emiten comunicaciones mediante nuevas operaciones de comunicación que tienen en cuenta el entorno de tareas, y que pueden tener semántica bloqueante o no bloqueante. La biblioteca TAMPI soporta las comunicaciones "two-sided" de MPI (p. ej., enviar/recibir mensajes), mientras que la biblioteca TAGASPI soporta las comunicaciones "one-sided" (también conocidas como RMA) proporcionadas por la interfaz GASPI. Además, nuestros mecanismos son suficientemente genéricos para incorporar cualquier otra interfaz bloqueante o no bloqueante (p. ej., para acelerar código a través de GPU) en modelos basados en tareas.