(English) High-performance computing (HPC) platforms are evolving towards increasingly complex architectures: many-core CPUs with multi-level NUMA hierarchies, heterogeneity with multiple classes of accelerators and higher-capacity interconnects. The increasing complexity and variety of resources in these machines make it harder for application programmers to use them efficiently and effectively. As a result, many resources in modern HPC clusters remain underutilized, limiting energy efficiency and the potential throughput of the machine.
This thesis argues that addressing these challenges requires co-design across the software stack, from runtime mechanisms and programming interfaces to system-level policies. We first study task-based runtimes and identify opportunities to reduce overheads and improve scalability on many-core machines, introducing novel scheduling and dependency-management techniques that maintain throughput under extreme concurrency. We then tackle programmability and performance in heterogeneous systems, proposing runtime and interface support to better overlap data movement, accelerator offloading, and CPU computation.
We also make a case for the effective co-design of applications and programming models through the study of an increasingly common application class: iterative data-flow computations, commonly used in simulations, iterative solvers, and AI. Through this study, we propose specific optimizations for this application class, showing how holistic co-design approaches can lead to significant speedups.
Finally, we present the nOS-V library with the goal of improving system-wide utilization through application co-scheduling, and we later apply the same methodology to obtain truly interoperable programming models, enabling multiple runtimes and parallel libraries to coexist within a single application with reduced mutual interference.
Overall, the contributions of this thesis provide a set of runtime techniques, programming abstractions, and system mechanisms that jointly improve throughput, efficiency, and composability on next-generation HPC systems.
(Català) Les plataformes de Computació d'Altes Prestacions (HPC) estan evolucionant cap a arquitectures cada cop més complexes: processadors amb grans quantitats de nuclis i amb jerarquies de memòria d'accés no uniforme (NUMA) multi-nivell, heterogeneïtat en els sistemes amb múltiples tipus d'acceleradors, i interconnexions de més capacitat. L'increment de complexitat i la varietat de recursos en aquestes màquines complica la feina d'utilitzar-les de forma eficient i efectiva, la qual recau en les persones que les programen. El resultat és que, als centres de dades moderns, molts recursos acaben sent infrautilitzats, empitjorant la seva eficiència energètica i limitant la seva capacitat.
Aquesta tesi proposa abordar aquests reptes mitjançant el disseny conjunt de components a totes les capes del programari, anant des dels mecanismes d'execució i les interfícies de programació fins al programari de sistema de baix nivell. Primerament, estudiem els mecanismes d'execució basats en tasques i identifiquem oportunitats per reduir el cost computacional associat a la gestió de tasques i millorar l'escalabilitat en sistemes amb molts nuclis, introduint noves tècniques de planificació i gestió de dependències que mantenen el rendiment fins i tot en nivells extrems de concurrència. A continuació, abordem els problemes de programabilitat i rendiment en sistemes heterogenis, proposant noves interfícies i sistemes d'execució per superposar de manera més efectiva el moviment de dades, l'execució en acceleradors i el càlcul al processador principal.
També argumentem a favor d'un disseny conjunt entre aplicacions i models de programació mitjançant l'estudi d'una classe d'aplicacions cada vegada més habituals: els càlculs iteratius basats en dependències de dades, utilitzats sovint en simulacions, mètodes matemàtics iteratius i intel·ligència artificial. A partir d'aquest estudi, proposem optimitzacions específiques per a aquesta classe d'aplicacions, mostrant com el disseny conjunt pot conduir a millores de rendiment significatives.
Finalment, presentem el programari de gestió de tasques nOS-V amb l'objectiu de millorar la utilització global del sistema mitjançant la coplanificació d'aplicacions, i posteriorment apliquem la mateixa metodologia per aconseguir models de programació realment interoperables, permetent que diversos models i biblioteques paral·leles convisquin dins d'una mateixa aplicació minimitzant la interferència mútua.
En conjunt, les contribucions d'aquesta tesi proporcionen tècniques d'execució, abstraccions de programació i mecanismes de sistema que, de manera conjunta, milloren el rendiment global, l'eficiència i la composabilitat dels sistemes HPC de nova generació.
(Español) Las plataformas de Computación de Altas Prestaciones (HPC) están evolucionando hacia arquitecturas cada vez más complejas: procesadores con grandes cantidades de núcleos y con jerarquías de memoria de acceso no uniforme (NUMA) multinivel, heterogeneidad en los sistemas con múltiples tipos de aceleradores, e interconexiones de mayor capacidad. El incremento de complejidad y la variedad de recursos en estas máquinas dificultan su uso eficiente y efectivo, una tarea que recae en las personas que las programan. Como resultado, en los centros de datos modernos muchos recursos terminan infrautilizados, empeorando su eficiencia energética y limitando su capacidad.
Esta tesis propone abordar estos retos mediante el diseño conjunto de componentes en todas las capas del software, abarcando desde los mecanismos de ejecución y las interfaces de programación hasta el software de sistema de bajo nivel. En primer lugar, estudiamos los mecanismos de ejecución basados en tareas e identificamos oportunidades para reducir el coste computacional asociado a la gestión de tareas y mejorar la escalabilidad en sistemas con muchos núcleos, introduciendo nuevas técnicas de planificación y gestión de dependencias que mantienen el rendimiento incluso en niveles extremos de concurrencia. A continuación, abordamos los problemas de programabilidad y rendimiento en sistemas heterogéneos, proponiendo nuevas interfaces y sistemas de ejecución para superponer de manera más efectiva el movimiento de datos, la ejecución en aceleradores y el cálculo en el procesador principal.
También defendemos un diseño conjunto entre aplicaciones y modelos de programación mediante el estudio de una clase de aplicaciones cada vez más habituales: los cálculos iterativos basados en dependencias de datos, utilizados frecuentemente en simulaciones, métodos matemáticos iterativos e inteligencia artificial. A partir de este estudio, proponemos optimizaciones específicas para esta clase de aplicaciones, mostrando cómo el diseño conjunto puede conducir a mejoras significativas de rendimiento.
Finalmente, presentamos el software de gestión de tareas nOS-V con el objetivo de mejorar la utilización global del sistema mediante la coplanificación de aplicaciones, y posteriormente aplicamos la misma metodología para lograr modelos de programación verdaderamente interoperables, permitiendo que diversos modelos y bibliotecas paralelas coexistan dentro de una misma aplicación minimizando la interferencia mutua.
En conjunto, las contribuciones de esta tesis proporcionan técnicas de ejecución, abstracciones de programación y mecanismos de sistema que, de manera conjunta, mejoran el rendimiento global, la eficiencia y la componibilidad de los sistemas HPC de nueva generación.
(English) High-Performance Computing (HPC) underpins scientific discovery and industrial innovation, yet its progress is tightly coupled to how effectively applications exploit modern supercomputers, which consist of thousands of nodes and hundreds of cores. Most supercomputing centers rely on the Linux Kernel at the core of their Operating System (OS). Linux provides applications with the foundation to interface with the capabilities of the underlying hardware, and while it excels in handling sequential and lightly parallel workloads, it might not suffice for highly parallel demands. To bridge the gap between application needs and the OS policy, developers increasingly rely on programming models to express parallelism through fork-join or data-flow dependencies that delegate work distribution to runtime systems. Runtimes simplify parallel programming by hiding Linux complexity and providing user-friendly alternatives that allow developers to focus on their algorithms instead of the underlying OS and hardware details. The coupling between Linux and runtime systems is essential to efficiently map the application's parallel workload to system resources with minimum OS interference and to maximize spatial and temporal locality. This is particularly important as the convergence of HPC, data analytics, and AI is transforming traditional HPC workloads that typically consisted of a single parallelized application into an ecosystem of services that interact with each other, opening new cooperation challenges.
This thesis presents a broad exploration of opportunities to tighten the bond between Linux and runtime systems from the I/O, memory, scheduling, and tracing subsystems. We analyze bottlenecks found in real scenarios and design and implement software solutions at both kernel and user level with the aim of improving overall performance, throughput, and latency.
On the I/O subsystem, we explore the challenge of integrating blocking operations in runtime systems. Blocking operations are oblivious from the runtime core management perspective and directly affect their capacity to keep cores busy with useful work. Better, seamless detection of such operations has the potential to enable I/O and computation overlapping.
On the memory subsystem, we face the challenge of transitioning from traditional homogeneous to heterogeneous memory systems. Traditional systems and applications are designed for homogeneous memory; however, a transparent kernel- or runtime-level solution could enable these applications to exploit the new paradigm without modification.
On the process scheduling subsystem, we extensively review the impact of context-switching for fine-grained suspendable tasks. Fine-grained parallel applications are characterized by exposing huge amounts of parallelism while consisting of small computational bursts. These pose a burden to the runtime, which needs to react quickly to keep cores busy with short-lived workloads, and to the kernel, which may need to swap threads on cores. In these cases, the context-switching latency becomes a bottleneck, and improving it can considerably raise performance.
Additionally, we analyze the impact of oversubscription on multi-process and multi-runtime workloads. Although these scenarios are usually avoided, the new paradigm powered by the AI adoption makes them increasingly more common. By rethinking the current thread scheduling policies, we can transparently improve performance while maintaining compatibility.
Lastly, On the tracing subsystem, we explore the availability of profiling tools for both runtime and kernel and elaborate on the benefits of having a conjoined solution to better understand their interactions, such as the detection of runtime imbalances caused by OS noise.
(Català) La Computació d'Alt Rendiment (HPC) sustenta el descobriment científic i la innovació industrial, però el seu progrés depèn de l'eficàcia amb què les aplicacions exploten els supercomputadors moderns, compostos per milers de nodes i centenars de CPUs. La majoria dels centres de supercomputació utilitzen el nucli Linux com a base del seu Sistema Operatiu (SO). Tot i que Linux destaca en càrregues de treball seqüencials i lleugerament paral·leles, pot no ser suficient per a demandes altament paral·leles. Per salvar aquesta bretxa, els desenvolupadors recorren a models de programació que expressen el paral·lelisme mitjançant dependències fork-join o de flux de dades, delegant la distribució del treball als runtimes. Aquests simplifiquen la programació paral·lela ocultant la complexitat de Linux i permetent als desenvolupadors centrar-se en els seus algorismes. L'acoblament entre Linux i els runtimes és essencial per mapejar eficientment la càrrega de treball sobre els recursos del sistema i maximitzar la localitat espacial i temporal. Això és especialment rellevant atès que la convergència de HPC, l'anàlisi de dades i la intel·ligència artificial està transformant les càrregues de treball HPC tradicionals en un ecosistema de serveis que interactuen entre si, obrint nous reptes de cooperació.
Aquesta tesi explora les oportunitats per estretar el vincle entre Linux i els runtimes des dels subsistemes d'E/S, memòria, planificació i instrumentació. Analitzem colls d'ampolla en escenaris reals i dissenyem solucions tant a nivell de nucli com d'usuari per millorar el rendiment global, el cabal i la latència.
En el subsistema d'E/S, explorem la integració d'operacions bloquejants en els runtimes. Aquestes operacions són invisibles per a la gestió de CPUs del runtime i afecten la seva capacitat per mantenir-les ocupades. Una detecció més precisa podria facilitar la superposició d'E/S i còmput.
En el subsistema de memòria, abordem la transició dels sistemes homogenis cap a sistemes heterogenis. Una solució transparent a nivell de nucli o runtime podria permetre que les aplicacions existents aprofitin el nou paradigma sense modificacions.
En el subsistema de planificació, analitzem l'impacte del canvi de context en tasques suspensibles de granularitat fina. Aquestes aplicacions exposen gran quantitat de paral·lelisme amb petites ràfegues computacionals, cosa que suposa una càrrega tant per al runtime com per al nucli. En aquests casos, la latència del canvi de context esdevé un coll d'ampolla, i la seva millora pot incrementar considerablement el rendiment.
A més, analitzem l'impacte de la sobresuscripció en càrregues de treball multiprocés i multi-runtime. Tot i que s'acostumen a evitar, l'adopció de la intel·ligència artificial els fa cada vegada més freqüents. Replantejant les polítiques de planificació, és possible millorar el rendiment de forma transparent.
Finalment, en el subsistema d'instrumentació, explorem eines de perfilat per al runtime i el nucli, i els beneficis d'una solució conjunta per comprendre millor les seves interaccions, com la detecció de desequilibris causats pel soroll del SO.
(Español) La Computación de Alto Rendimiento (HPC) sustenta el descubrimiento científico y la innovación industrial, pero su progreso depende de la eficacia con que las aplicaciones explotan los supercomputadores modernos, compuestos por miles de nodos y cientos de CPUs. La mayoría de los centros de supercomputación utilizan el núcleo Linux como base de su Sistema Operativo (SO). Aunque Linux destaca en cargas de trabajo secuenciales y ligeramente paralelas, puede no ser suficiente para demandas altamente paralelas. Para salvar esta brecha, los desarrolladores recurren a modelos de programación que expresan el paralelismo mediante dependencias fork-join o de flujo de datos, delegando la distribución del trabajo en los runtimes. Estos simplifican la programación paralela ocultando la complejidad de Linux y permitiendo a los desarrolladores centrarse en sus algoritmos. El acoplamiento entre Linux y los runtimes es esencial para mapear eficientemente la carga de trabajo sobre los recursos del sistema y maximizar la localidad espacial y temporal. Esto es especialmente relevante dado que la convergencia de HPC, el análisis de datos y la inteligencia artificial está transformando las cargas de trabajo HPC tradicionales en un ecosistema de servicios que interactúan entre sí, abriendo nuevos retos de cooperación.
Esta tesis explora las oportunidades para estrechar el vínculo entre Linux y los runtimes desde los subsistemas de E/S, memoria, planificación e instrumentación. Analizamos cuellos de botella en escenarios reales y diseñamos soluciones tanto a nivel de núcleo como de usuario para mejorar el rendimiento global, el caudal y la latencia.
En el subsistema de E/S, exploramos la integración de operaciones bloqueantes en los runtimes. Estas operaciones son invisibles para la gestión de CPUs del runtime y afectan a su capacidad para mantenerlas ocupadas. Una detección más precisa podría facilitar la superposición de E/S y cómputo.
En el subsistema de memoria, abordamos la transición de los sistemas homogéneos hacia sistemas heterogéneos. Una solución transparente a nivel de núcleo o runtime podría permitir que las aplicaciones existentes aprovechen el nuevo paradigma sin modificaciones.
En el subsistema de planificación, analizamos el impacto del cambio de contexto en tareas suspendibles de granularidad fina. Estas aplicaciones exponen gran cantidad de paralelismo con pequeñas ráfagas computacionales, lo que supone una carga tanto para el runtime como para el núcleo. En estos casos, la latencia del cambio de contexto se convierte en un cuello de botella, y su mejora puede incrementar considerablemente el rendimiento.
Además, analizamos el impacto de la sobresuscripción en cargas de trabajo multiproceso y multi-runtime. Aunque suelen evitarse, la adopción de la inteligencia artificial los hace cada vez más frecuentes. Replanteando las políticas de planificación, es posible mejorar el rendimiento de forma transparente.
Finalmente, en el subsistema de instrumentación, exploramos herramientas de per
Heterogeneity is the prevalent trend in the rapidly evolving high-performance computing (HPC) landscape in both hardware and application software. The diversity in hardware platforms, currently comprising various accelerators and a future possibility of specializable chiplets, poses a significant challenge for scientific software developers aiming to harness optimal performance across different computing platforms while maintaining the quality of solutions when their applications are simultaneously growing more complex. Code synthesis and code generation can provide mechanisms to mitigate this challenge. We have developed a divide and conquer approach where different aspects of performance are handled by different stand-alone tools that are interfaced with the application through generated code. This portability system, ORCHA, enables users to configure and orchestrate their computations among available resources on a platform by specifying a high-level recipe, thereby permitting a
many-to-many
paradigm where each recipe results in a different variant of the application. The core design goal is to let users decide the application’s hardware mapping and orchestration by editing only the high-level recipe—without modifying the maintained source code or binding the application to a particular runtime system. Tools in ORCHA distribution are: CG-Kit for translating the recipe into an execution graph; Milhoja to execute the graph by orchestrating data and task movement among hardware resources; and Macroprocessor that enables users to define their own code-shorthand for higher composability and easier management of code variants. Additionally, the design of ORCHA permits tools to work in a plug-and-play mode where the application can build and run without CG-Kit and Milhoja, and either tool can be swapped out for other tools with similar capabilities by modifying the code generation portion of ORCHA. In this paper, we describe the design of ORCHA and the role that code-generation plays in isolating applications from tools. We demonstrate the breadth of configurations ORCHA enables with a case study in which an application configuration is realized on three distinct hardware mappings—a GPU-centric, a CPU/GPU balanced, and a CPU/GPU concurrent layouts by using different recipes.
Youngjun Lee, Klaus Weide, Wesley Kwiecinski et al.· The international journal of...· 1 citation
Modern High Performance Computing (HPC) workloads exchange datasets at high velocity to enable data-driven science. HPC systems employ hardware and software I/O accelerators to enable efficient data exchange. However, domain scientists and software engineers must manually request specific hardware accelerators and manually integrate software accelerators into their workloads, significantly hindering their adoption. Recently, scientists have proposed I/O intents, defined as “why”, “what”, and “how” users or applications perform certain I/O operations, that can be used to automatically configure storage systems for the user. We designed an intent-driven scheduler plugin called IFlux that uses the workload’s I/O intents to assist the HPC system scheduler to automatically and dynamically allocate hardware and software accelerators. In this work, IFlux advances the current state-of-the-art in three key aspects. First, IFlux automatically and efficiently maps different I/O intents to various hardware and software accelerators with a throughput of 3.5 M intents per second with a scheduler overhead of 0.02%. Second, IFlux provides a scheduler workflow that uses a scheduler’s job specification enhanced with intents to allocate the required storage accelerators, deploy necessary middleware software, and enable workloads to use the allocated hardware and deployed software transparently with a runtime overhead of 0.01%. Finally, IFlux speeds up popular benchmarks such as the IOR and DLIO Benchmarks, which represent six classes of workloads from simulation, data analytics, and artificial intelligence, by up to 147× for specific use cases. In conclusion, IFlux enhances existing HPC schedulers with an intent-driven approach to speed up large-scale HPC workloads such as the 1000 Genomes workflow and Megatron Deepspeed by up to 3.12× on an institutional cluster.
Hariharan Devarajan, Vanessa V. Sochat, Daniel Milroy et al.· IEEE Transactions on Paralle...· 0 citations
A benchmarking study of Python-Rust interoperability reveals that the Rust enhanced versions systematically execute faster than pure Pythoncode- up to three times faster in some cases.
Srikant Singh, R.pradeep Raj· International Journal For Mu...· 0 citations
With the rapid growth of artificial intelligence (AI) and high-performance computing (HPC), GPUs and other accelerators have become a shared computing substrate for a wide range of workloads. However, many shared accelerator clusters still rely on coarse device-level allocation, which often leads to low effective utilization, resource fragmentation, and long queueing delays. Although pooling technologies offer a promising direction, existing approaches remain limited in supporting fine-grained, low overhead sharing across heterogeneous accelerators and diverse co-located workloads. This paper presents gPooling, a hardware-agnostic accelerator pooling framework based on driver-level interception. gPooling creates elastic virtual devices on demand and extends fine-grained sharing across heterogeneous accelerators through a unified control path. We evaluate gPooling using benchmarks derived from real cluster traces and through deployment in a production GPU cluster. Results show that gPooling improves accelerator utilization, reduces user waiting time, and increases the overall efficiency of shared accelerator environments.
Kaicheng Guo, Jingyi Chen, Chen Chen et al.· IEEE Transactions on Paralle...· 1 citation
Hybrid CPU architectures have entered the mainstream desktop computing with the announcement of Intel's Alderlake architecture. Such a transition to heterogeneous CPU architecture has various performance and power implications on existing parallel workloads. In this paper we study the effects and impact of hybrid core and cache architecture on the performance of highly parallel HPC workloads. We also illustrate interesting thread scaling behavior for parallel workloads and describes the reason for such behavior both qualitatively and quantitatively. We also explore the impact of hybrid cache architecture on parallel shared data HPC applications. Finally, we illustrate that 1) parallel applications with work imbalance (i.e., threads in application perform different amount of work) scale better across hybrid cores when thread affinity is disabled and 2) hybrid cache architecture has very little impact on parallel shared data applications except for some workloads with locks. This work lays the foundation for our future work which focuses on extending this work to model parallel workloads and hybrid CPU architectures to improve their performance in terms of execution time, memory usage and power consumption.
Nanda Velugoti, Joseph Manzano, Nathan R. Tallent et al.· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
