Search

International audience; We consider the distributed Cholesky factorization on homogeneous nodes. Inspired by recent progress on asymptotic lower bounds on the total communication volume required to perform Cholesky factorization, we present an original data distribution, Symmetric Block Cyclic (SBC), designed to take advantage of the symmetry of the matrix. We prove that SBC reduces the overall communication volume between nodes by a factor of square root of 2 compared to the standard 2D blockcyclic distribution. SBC can easily be implemented within the paradigm of task-based runtime systems. Experiments using the Chameleon library over the StarPU runtime system demonstrate that the SBC distribution reduces the communication volume as expected, and also achieves better performance and scalability than the classical 2D block-cyclic allocation scheme in all configurations. We also propose a 2.5D variant of SBC and prove that it further improves the communication and performance benefits.

Direct Air Capture (DAC) technologies are gaining interest in the concept of carbon utilization and Power-to-Gas (PtG), as the economic valorization of the CO into methane provides a viable pathway to allow DAC systems to mature. However, research on DAC mainly focuses on isolated systems, and the system performance depends on parameters that are highly uncertain. To study the integration of DAC in PtG, we developed a DAC-PtG model, performed an Energy, Exergy, Economic and Environmental (4E) analysis and implemented uncertainty quantification to consider the uncertain environment. The results illustrate that the DAC-PtG system is autothermal when introducing a two-stage mechanical vapor recompression unit at the DAC outlet. The exergy efficiency ranges between 51.3% and 52.6% within 3 standard deviations, for which the uncertainty is driven by the ambient conditions and the uncertain heat of desorption. The methane issued from DAC-PtG has a lower carbon footprint than fossil methane when the carbon footprint of the electricity supply is below or equal to 0.12 kg˙CO˙2-eq /kWh. The Levelized Cost of Synthetic Natural Gas (LCSNG) ranges between 130 €/ MWh and 744 €/ MWh, following an uncertain electricity price and uncertain expenses related to DAC and electrolysis. Therefore, bulk manufacturing, further maturing of these technologies and more demonstration projects are required to reduce the uncertainty of the LCSNG. Future works will consider intermittent renewable energy sources to supply power.

The limited memory of GPUs induces serious problems in the training phase of deep neural networks (DNNs). Indeed, with the recent tremendous increase in the size of DNN models, which can now routinely include hundreds of billions or even trillions of parameters, it is impossible to store these models in the memory of a GPU and several strategies have been devised to solve this problem. In this paper, we analyze in detail the strategy that consists in offloading the weights of some model layers from the GPU to the CPU when they are not used. Since the PCI bus bandwidth between the GPU and the CPU is limited, it is crucial to know which layers should be transferred (offloaded and prefetched) and when. We prove that this problem is in general NP-Complete in the strong sense and we propose a lower bound formulation in the form of an Integer Linear Program (ILP). We propose heuristics to select the layers to offload and to build the schedule of data transfers. We show that this approach allows to build near-optimal weight offloading strategies on realistic size DNNs and architectures.

Synthetic iron-sulfur cubanes are models for biological cofactors, which are essential to delineate oxidation states in the more complex enzymatic systems. However, a complete series of [Fe4S4]n complexes spanning all redox states accessible by 1-electron transformations of the individual iron atoms (n = 0-4+) has never been prepared, deterring the methodical comparison of structure and spectroscopic signature. Here, we demonstrate that the use of a bulky arylthiolate ligand promoting the encapsulation of alkali-metal cations in the vicinity of the cubane enables the synthesis of such a series. Characterization by EPR, 57Fe Mössbauer spectroscopy, UV-visible electronic absorption, variable-temperature X-ray diffraction analysis, and cyclic voltammetry reveals key trends for the geometry of the Fe4S4 core as well as for the Mössbauer isomer shift, which both correlate systematically with oxidation state. Furthermore, we confirm the S = 4 electronic ground state of the most reduced member of the series, [Fe4S4]0, and provide electrochemical evidence that it is accessible within 0.82 V from the [Fe4S4]2+ state, highlighting its relevance as a mimic of the nitrogenase iron protein cluster., Proceedings of the National Academy of Sciences of the United States of America, 119 (31), ISSN:0027-8424, ISSN:1091-6490

International audience; The training phase in Deep Neural Networks (DNNs) is very computationally intensive and is nowadays often performed on parallel computing platforms, ranging from a few GPUs to several thousand GPUs. The strategy of choice for the parallelization of training is the so-called data parallel approach, based of the parallel training of the different inputs (typically images) and a the aggregation of network weights with collective communications (AllReduce). The scalability of this approach is limited both by the memory available on each node and the networking capacities for collective operations. Recently, a parallel model approach, in which the network weights are distributed and images are trained in a pipeline/stream manner over the computational nodes has been proposed (Pipedream, Gpipe). In this paper, we formalize in detail the optimization problem associated with the placement of DNN layers onto computation resources when using pipelined model parallelism, and we derive a dynamic programming based heuristic, MadPipe, that allows to significantly improve the performance of the parallel model approach compared to the literature.

The training phase in Deep Neural Networks has become an important source of computing resource usage and because of the resulting volume of computation, it is crucial to perform it efficiently on parallel architectures. Even today, data parallelism is the most widely used method, but the associated requirement to replicate all the weights on the totality of computation resources poses problems of memory at the level of each node and of collective communications at the level of the platform. In this context, the model parallelism, which consists in distributing the different layers of the network over the computing nodes, is an attractive alternative. Indeed, it is expected to better distribute weights (to cope with memory problems) and it does not imply large collective communications since only forward activations are communicated. However, to be efficient, it must be combined with a pipelined/streaming approach, which leads in turn to new memory costs. The goal of this paper is to model these memory costs in detail and to show that it is possible to formalize this optimization problem as an Integer Linear Program (ILP)., La phase d’apprentissage dans les réseaux neuronaux profonds est devenue une source importante d’utilisation des ressources de calcul et, en raison du volume de calcul qui en résulte, il est crucial de l’exécuter efficacement sur des architectures parallèles. Aujourd’hui encore, le parallélisme de données est la méthode la plus utilisée, mais l’exigence associée de répliquer tous les poids sur la totalité des ressources de calcul pose des problèmes de mémoire au niveau de chaque nœud et de communications collectives au niveau de la plateforme. Dans ce contexte, le parallélisme de modèle, qui consiste à répartir les différentes couches du réseau sur les nœuds de calcul, est une alternative intéressante. En effet, il est censé mieux répartir les poids (pour faire face aux problèmes de mémoire) et il n’implique pas de grosses communications collectives puisque seules les activations "forward" sont communiquées. Cependant, pour être efficace, elle doit être combinée avec une approche pipelinée/streaming, ce qui entraîne à son tour de nouveaux coûts mémoire. L’objectif de cet article est de modéliser ces coûts de mémoire en détail et de montrer qu’il est possible de formaliser ce problème d’optimisation comme un programme linéaire en nombre entier (ILP).

International audience; Rematerialization and offloading are two well known strategies to save memory during the training phase of deep neural networks, allowing data scientists to consider larger models, batch sizes or higher resolution data. Rematerialization trades memory for computation time, whereas Offloading trades memory for data movements. As these two resources are independent, it is appealing to consider the simultaneous combination of both strategies to save even more memory. We precisely model the costs and constraints corresponding to Deep Learning frameworks such as PyTorch or Tensorflow, we propose optimal algorithms to find a valid sequence of memory-constrained operations and finally, we evaluate the performance of proposed algorithms on realistic networks and computation platforms. Our experiments show that the possibility to offload can remove one third of the overhead of rematerialization, and that together they can reduce the memory used for activations by a factor 4 to 6, with an overhead below 20%.

Concurrent kernel execution is a relatively new feature in modern GPUs, which was designed to improve hardware utilization and the overall system throughput. However, the decision on the simultaneous execution of tasks is performed by the hardware with a leftover policy, that assigns as many resources as possible for one task and then assigns the remaining resources to the next task. This can lead to unreasonable use of resources. In this work, we tackle the problem of co-scheduling for GPUs with and without preemption, with the focus on determining the kernels submission order to reduce the number of preemptions and the kernels makespan, respectively. We propose a graph-based theoretical model to build preemptive and non-preemptive schedules. We show that the optimal preemptive makespan can be computed by solving a Linear Program in polynomial time, and we propose an algorithm based on this solution which minimizes the number of preemptions. We also propose an algorithm that transforms a preemptive solution of optimal makespan into a non-preemptive solution with the smallest possible preemption overhead. We show, however, that finding the minimal amount of preemptions among all preemptive solutions of optimal makespan is a NP-hard problem, and computing the optimal non-preemptive schedule is also NP-hard. In addition, we study the non-preemptive problem, without searching first for a good preemptive solution, and present a Mixed Integer Linear Program solution to this problem. We performed experiments on real-world GPU applications and our approach can achieve optimal makespan by preempting 6 to 9% of the tasks. Our non-preemptive approach, on the other side, obtains makespan within 2.5% of the optimal preemptive schedules, while previous approaches exceed the preemptive makespan by 5 to 12%.

Synthetic iron-sulfur cubanes are essential models for biological cofactors in the more complex enzymatic environments. However, a complete series of [Fe4S4]n complexes spanning all biorelevant oxidation states (n = 0-3+) has never been prepared. Here, we demonstrate that the use of a bulky arylthiolate ligand promoting the encapsulation of alkali-metal cations in the vicinity of the cubane enables the synthesis of such a series. Characterization by EPR, 57Fe Mössbauer spectroscopy, UV-Vis electronic absorption and variable-temperature X-ray diffraction analysis reveals key trends for the Fe4S4 core’s geometry as well as for the Mössbauer isomer shift, which both correlate systematically with oxidation state. Furthermore, we confirm the S=4 electronic ground state of the most reduced member, [Fe4S4]0, in agreement with that proposed for the all-ferrous cubanes in Nature., ChemRxiv

International audience; In High Performance Computing, heterogeneity is now the norm with specialized accelerators like GPUs providing efficient computational power. Resulting complexity led to the development of task-based runtime systems, where complex computations are described as task graphs, and scheduling decisions are made at run-time to perform load balancing between all resources of the platforms. Developing good scheduling strategies, even at the scale of a single node, and analyzing them both theoretically and in practice is expected to have a very high impact on the performance of current HPC systems. The special case of two kinds of resources, typically CPUs and GPUs is already of great practical interest. The scheduling policy Hetero-Prio has been proposed in the context of fast multipole computations (FMM), and has been extended to general task graphs with very promising results. In this paper, we provide a theoretical study of the performance of HeteroPrio, by proving approximation bounds compared to the optimal schedule, both in the case of independent tasks and in the case of general task graphs. Interestingly, our results establish that spoliation (a technique that enables resources to restart uncompleted tasks on another resource) is enough to prove bounded approximation ratios for a list scheduling algorithm on two unrelated resources, which is known to be impossible otherwise. This result holds true both for independent and dependent tasks graphs. Additionally, we provide an experimental evaluation of HeteroPrio on real task graphs from dense linear algebra computation, that establishes its strong performance in practice.

Burst-Buffers are high throughput and small size storage which are being used as an intermediate storage between the Parallel File System (Parallel File System) and the computational nodes of modern HPC systems. They can allow to hinder to contention to the Parallel File System, a shared resource whose read and write performance increase slower than processing power in HPC systems. A second usage is to accelerate data transfers and to hide the latency to the Parallel File System. In this paper, we concentrate on the first usage. We propose a model for Burst-Buffers and application transfers.We consider the problem of dimensioning and sharing the Burst-Buffers between several applications. This dimensioning can be done either dynamically or statically. The dynamic allocation considers that any application can use any available portion of the Burst-Buffers. The static allocation considers that when a new application enters the system, it is assigned some portion of the Burst-Buffers which cannot be used by the other applications until that application leaves the system and its data is purged from it. We show that the general sharing problem to guarantee fair performance for all applications is an NP-Complete problem. We give a polynomial time algorithms for the special case of finding the optimal buffer size such that no application is slowed down due to Parallel File System contention, both in the static and dynamic cases. Finally, we provide evaluations of our algorithms in realistic settings. We use those to discuss how to minimize the overhead of the static allocation of buffers compared to the dynamic allocation.; Nous nous intéressons à l’utilisation de Burst-Buffers en temps qu’espace de stockage intermédiaire entre les nœuds de calcul et le Système de Fichiers Parallèles (PFS). Ce dimensionnement peut être statique (à l’arrivée d’une application dans le système), ou dynamique (en fonction des demandes Entrées-Sorties).Nous montrons que le problème général de partager équitablement les buffers entre applications est NP-complet. Nous montrons que dans le cas particulier où l’on cherche à minimiser la taille totale du buffer pour qu’aucune application ne soit ralentie est résolvable en temps polynomial. Pour résoudre ce problème nous proposons un programme linéaire.Finalement nous proposons des évaluations à taille de buffer fixé pour montrer la performance de certains algorithmes naifs communs.