3.3.1 Parallel sparse direct solvers

For the solution of large sparse linear systems, we design numerical schemes and software packages for direct and hybrid parallel solvers. Sparse direct solvers are mandatory when the linear system is very ill-conditioned; such a situation is often encountered in structural mechanics codes, for example. Therefore, to obtain an industrial software tool that must be robust and versatile, high-performance sparse direct solvers are mandatory, and parallelism is then necessary for reasons of memory capability and acceptable solution time. Moreover, in order to solve efficiently 3D problems with more than 50 million unknowns, which is now a reachable challenge with new multicore supercomputers, we must achieve good scalability in time and control memory overhead. Solving a sparse linear system by a direct method is generally a highly irregular problem that induces some challenging algorithmic problems and requires a sophisticated implementation scheme in order to fully exploit the capabilities of modern supercomputers.

New supercomputers incorporate many microprocessors which are composed of one or many computational cores. These new architectures induce strongly hierarchical topologies. These are called NUMA architectures. In the context of distributed NUMA architectures, in collaboration with the Inria STORM team, we study optimization strategies to improve the scheduling of communications, threads and I/O. We have developed dynamic scheduling designed for NUMA architectures in the PaStiX solver. The data structures of the solver, as well as the patterns of communication have been modified to meet the needs of these architectures and dynamic scheduling. We are also interested in the dynamic adaptation of the computation grain to use efficiently multi-core architectures and shared memory. Experiments on several numerical test cases have been performed to prove the efficiency of the approach on different architectures. Sparse direct solvers such as PaStiX are currently limited by their memory requirements and computational cost. They are competitive for small matrices but are often less efficient than iterative methods for large matrices in terms of memory. We are currently accelerating the dense algebra components of direct solvers using block low-rank compression techniques.

In collaboration with the ICL team from the University of Tennessee, and the STORM team from Inria, we are evaluating the way to replace the embedded scheduling driver of the PaStiX solver by one of the generic frameworks, PaRSEC or StarPU, to execute the task graph corresponding to a sparse factorization. The aim is to design algorithms and parallel programming models for implementing direct methods for the solution of sparse linear systems on emerging computer equipped with GPU accelerators. More generally, this work will be performed in the context of the ANR SOLHARIS project which aims at designing high performance sparse direct solvers for modern heterogeneous systems. This ANR project involves several groups working either on the sparse linear solver aspects (HiePACS and ROMA from Inria and APO from IRIT), on runtime systems (STORM from Inria) or scheduling algorithms (HiePACS and ROMA from Inria). The results of these efforts will be validated in the applications provided by the industrial project members, namely CEA-CESTA and Airbus Central R & T.

3.3.2 Hybrid direct/iterative solvers based on algebraic domain decomposition techniques

One route to the parallel scalable solution of large sparse linear systems in parallel scientific computing is the use of hybrid methods that hierarchically combine direct and iterative methods. These techniques inherit the advantages of each approach, namely the limited amount of memory and natural parallelization for the iterative component and the numerical robustness of the direct part. The general underlying ideas are not new since they have been intensively used to design domain decomposition techniques; those approaches cover a fairly large range of computing techniques for the numerical solution of partial differential equations (PDEs) in time and space. Generally speaking, it refers to the splitting of the computational domain into sub-domains with or without overlap. The splitting strategy is generally governed by various constraints/objectives but the main one is to express parallelism. The numerical properties of the PDEs to be solved are usually intensively exploited at the continuous or discrete levels to design the numerical algorithms so that the resulting specialized technique will only work for the class of linear systems associated with the targeted PDE.

In that context, we continue our effort on the design of algebraic non-overlapping domain decomposition techniques that rely on the solution of a Schur complement system defined on the interface introduced by the partitioning of the adjacency graph of the sparse matrix associated with the linear system. Although it is better conditioned than the original system the Schur complement needs to be precondition to be amenable to a solution using a Krylov subspace method. Different hierarchical preconditioners will be considered, possibly multilevel, to improve the numerical behaviour of the current approaches implemented in our software library MaPHyS. This activity will be developed further developped in the H2020 EoCoE2 project. In addition to this numerical studies, advanced parallel implementation will be developed that will involve close collaborations between the hybrid and sparse direct activities.

3.3.3 Linear Krylov solvers

Preconditioning is the main focus of the two activities described above. They aim at speeding up the convergence of a Krylov subspace method that is the complementary component involved in the solvers of interest for us. In that framework, we believe that various aspects deserve to be investigated; we will consider the following ones:

• Preconditioned block Krylov solvers for multiple right-hand sides. In many large scientific and industrial applications, one has to solve a sequence of linear systems with several right-hand sides given simultaneously or in sequence (radar cross section calculation in electromagnetism, various source locations in seismic, parametric studies in general, ...). For “simultaneous" right-hand sides, the solvers of choice have been for years based on matrix factorizations as the factorization is performed once and simple and cheap block forward/backward substitutions are then performed. In order to effectively propose alternative to such solvers, we need to have efficient preconditioned Krylov subspace solvers. In that framework, block Krylov approaches, where the Krylov spaces associated with each right-hand side are shared to enlarge the search space will be considered. They are not only attractive because of this numerical feature (larger search space), but also from an implementation point of view. Their block-structures exhibit nice features with respect to data locality and re-usability that comply with the memory constraint of multicore architectures. We will continue the numerical study and design of the block GMRES variant that combines inexact break-down detection, deflation at restart and subspace recycling. Beyond new numerical investigations, a software implementation to be included in our linear solver libray Fabulous originately developed in the context of the DGA HiBox project and further developped in the LynCs (Linear Algebra, Krylov-subspace methods, and multi-grid solvers for the discovery of New Physics) sub-project of Prace-6IP.
• Extension or modification of Krylov subspace algorithms for multicore architectures: finally to match as much as possible to the computer architecture evolution and get as much as possible performance out of the computer, a particular attention will be paid to adapt, extend or develop numerical schemes that comply with the efficiency constraints associated with the available computers. Nowadays, multicore architectures seem to become widely used, where memory latency and bandwidth are the main bottlenecks; investigations on communication avoiding techniques will be undertaken in the framework of preconditioned Krylov subspace solvers as a general guideline for all the items mentioned above.

3.3.4 Eigensolvers

Many eigensolvers also rely on Krylov subspace techniques. Naturally some links exist between the Krylov subspace linear solvers and the Krylov subspace eigensolvers. We plan to study the computation of eigenvalue problems with respect to the following two different axes:

• Exploiting the link between Krylov subspace methods for linear system solution and eigensolvers, we intend to develop advanced iterative linear methods based on Krylov subspace methods that use some spectral information to build part of a subspace to be recycled, either though space augmentation or through preconditioner update. This spectral information may correspond to a certain part of the spectrum of the original large matrix or to some approximations of the eigenvalues obtained by solving a reduced eigenproblem. This technique will also be investigated in the framework of block Krylov subspace methods.
• In the context of the calculation of the ground state of an atomistic system, eigenvalue computation is a critical step; more accurate and more efficient parallel and scalable eigensolvers are required.

3.3.5 Fast Solvers for FEM/BEM Coupling

In this research project, we are interested in the design of new advanced techniques to solve large mixed dense/sparse linear systems, the extensive comparison of these new approaches to the existing ones, and the application of these innovative ideas on realistic industrial test cases in the domain of aeroacoustics (in collaboration with Airbus Central R & T).

• The use of $\mathscr{H}$-matrix solvers on these problems has been investigated in the context of the PhD of A. Falco. Airbus CR&T, in collaboration with Inria Bordeaux Sud-Ouest, has developed a task-based $\mathscr{H}$-matrix solver on top of the runtime engine StarPU. Ideas coming from the field of sparse direct solvers (such as nested dissection or symbolic factorization) have been tested within $\mathscr{H}$-matrices.
• The question of parallel scalability of task-based tools is an active subject of research, using new communication engine such as NewMadeleine, that will be investigated during this project, in conjunction with new algorithmic ideas on the task-based writing of $\mathscr{H}$-matrix algorithms.
• Naturally, comparison with existing tools will be performed on large realistic test cases. Coupling schemes between these tools and the hierarchical methods used in $\mathscr{H}$-matrix will be developed and benched as well.

3.4.1 Improvement of calculation efficiency

Nowadays, the high performance computing community is examining alternative architectures that address the limitations of modern cache-based designs. GPU (Graphics Processing Units) and the Cell processor have thus already been used in astrophysics and in molecular dynamics. The Fast Mutipole Method has also been implemented on GPU. We intend to examine the potential of using these forthcoming processors as a building block for high-end parallel computing in N-body calculations. More precisely, we want to take advantage of our specific underlying BLAS routines to obtain an efficient and easily portable FMM for these new architectures. Algorithmic issues such as dynamic load balancing among heterogeneous cores will also have to be solved in order to gather all the available computation power. This research action will be conduced on close connection with the activity described in Section 3.2.

3.4.2 Non uniform distributions

In many applications arising from material physics or astrophysics, the distribution of the data is highly non uniform and the data can grow between two time steps. As mentioned previously, we have proposed a hybrid MPI-thread algorithm to exploit the data locality within each node. We plan to further improve the load balancing for highly non uniform particle distributions with small computation grain thanks to dynamic load balancing at the thread level and thanks to a load balancing correction over several simulation time steps at the process level.

3.4.3 Fast multipole method for dislocation operators

The engine that we develop will be extended to new potentials arising from material physics such as those used in dislocation simulations. The interaction between dislocations is long ranged ($O(1/r)$) and anisotropic, leading to severe computational challenges for large-scale simulations. Several approaches based on the FMM or based on spatial decomposition in boxes are proposed to speed-up the computation. In dislocation codes, the calculation of the interaction forces between dislocations is still the most CPU time consuming. This computation has to be improved to obtain faster and more accurate simulations. Moreover, in such simulations, the number of dislocations grows while the phenomenon occurs and these dislocations are not uniformly distributed in the domain. This means that strategies to dynamically balance the computational load are crucial to achieve high performance.

3.4.4 Fast multipole method for boundary element methods

The boundary element method (BEM) is a well known solution of boundary value problems appearing in various fields of physics. With this approach, we only have to solve an integral equation on the boundary. This implies an interaction that decreases in space, but results in the solution of a dense linear system with $O\left(N^3\right)$ complexity. The FMM calculation that performs the matrix-vector product enables the use of Krylov subspace methods. Based on the parallel data distribution of the underlying octree implemented to perform the FMM, parallel preconditioners can be designed that exploit the local interaction matrices computed at the finest level of the octree. This research action will be conduced on close connection with the activity described in Section 3.3. Following our earlier experience, we plan to first consider approximate inverse preconditionners that can efficiently exploit these data structures.

3.5.1 Dynamic load-balancing with variable number of processors

As a preliminary step related to the dynamic load balancing of coupled codes, we focus on the problem of dynamic load balancing of a single parallel code, with variable number of processors. Indeed, if the workload varies drastically during the simulation, the load must be redistributed regularly among the processors. Dynamic load balancing is a well studied subject but most studies are limited to an initially fixed number of processors. Adjusting the number of processors at runtime allows one to preserve the parallel code efficiency or keep running the simulation when the current memory resources are exceeded. We call this problem, MxN graph repartitioning.

We propose some methods based on graph repartitioning in order to re-balance the load while changing the number of processors. These methods are split in two main steps. Firstly, we study the migration phase and we build a “good” migration matrix minimizing several metrics like the migration volume or the number of exchanged messages. Secondly, we use graph partitioning heuristics to compute a new distribution optimizing the migration according to the previous step results.

3.5.2 Load balancing of coupled codes

As stated above, the load balancing of coupled code is a major issue, that determines the performance of the complex simulation, and reaching high performance can be a great challenge. In this context, we develop new graph partitioning techniques, called co-partitioning. They address the problem of load balancing for two coupled codes: the key idea is to perform a "coupling-aware" partitioning, instead of partitioning these codes independently, as it is classically done. More precisely, we propose to enrich the classic graph model with inter-edges, which represent the coupled code interactions. We describe two new algorithms, and compare them to the naive approach. In the preliminary experiments we perform on synthetically-generated graphs, we notice that our algorithms succeed to balance the computational load in the coupling phase and in some cases they succeed to reduce the coupling communications costs. Surprisingly, we notice that our algorithms do not degrade significantly the global graph edge-cut, despite the additional constraints that they impose.

Besides this, our co-partitioning technique requires to use graph partitioning with fixed vertices, that raises serious issues with state-of-the-art software, that are classically based on the well-known recursive bisection paradigm (RB). Indeed, the RB method often fails to produce partitions of good quality. To overcome this issue, we propose a new direct $k$-way greedy graph growing algorithm, called KGGGP, that overcomes this issue and succeeds to produce partition with better quality than RB while respecting the constraint of fixed vertices. Experimental results compare KGGGP against state-of-the-art methods, such as Scotch, for real-life graphs available from the popular DIMACS'10 collection.

3.5.3 Load balancing strategies for hybrid sparse linear solvers

Graph handling and partitioning play a central role in the activity described here but also in other numerical techniques detailed in sparse linear algebra Section. The Nested Dissection is now a well-known heuristic for sparse matrix ordering to both reduce the fill-in during numerical factorization and to maximize the number of independent computation tasks. By using the block data structure induced by the partition of separators of the original graph, very efficient parallel block solvers have been designed and implemented according to super-nodal or multi-frontal approaches. Considering hybrid methods mixing both direct and iterative solvers such as MaPHyS, obtaining a domain decomposition leading to a good balancing of both the size of domain interiors and the size of interfaces is a key point for load balancing and efficiency in a parallel context.

We intend to revisit some well-known graph partitioning techniques in the light of the hybrid solvers and design new algorithms to be tested in the Scotch package.

4.2.1 High performance simulation for ITER tokamak

Scientific simulation for ITER tokamak modeling provides a natural bridge between theory and experimentation and is also an essential tool for understanding and predicting plasma behavior. Recent progresses in numerical simulation of fine-scale turbulence and in large-scale dynamics of magnetically confined plasma have been enabled by access to petascale supercomputers. These progresses would have been unreachable without new computational methods and adapted reduced models. In particular, the plasma science community has developed codes for which computer runtime scales quite well with the number of processors up to thousands cores. The research activities of HiePACS concerning the international ITER challenge have started in the Inria Project Lab C2S@Exa in collaboration with CEA-IRFM and were related to two complementary studies: a first one concerning the turbulence of plasma particles inside a tokamak (in the context of GYSELA code) and a second one concerning the MHD instability edge localized modes (in the context of JOREK code). The activity concerning GYSELA was completed at the end of 2018.

Other numerical simulation tools designed for the ITER challenge aim at making a significant progress in understanding active control methods of plasma edge MHD instability Edge Localized Modes (ELMs) which represent a particular danger with respect to heat and particle loads for Plasma Facing Components (PFC) in the tokamak. The goal is to improve the understanding of the related physics and to propose possible new strategies to improve effectiveness of ELM control techniques. The simulation tool used (JOREK code) is related to non linear MHD modeling and is based on a fully implicit time evolution scheme that leads to 3D large very badly conditioned sparse linear systems to be solved at every time step. In this context, the use of PaStiX library to solve efficiently these large sparse problems by a direct method is a challenging issue.

This activity continues within the context of the EoCoE2 project, in which the PaStiX solver is identified to allow the processing of very larger linear systems for the nuclear fusion code TOKAM3X from CEA-IRFM. Contrary to the JOREK code, the problem to be treated corresponds to the complete 3D volume of the plasma torus. The objective is to be competitive, for complex geometries, compared to an Algebraic MultiGrid approach designed by one partner of EoCoE2.

4.2.2 Numerical and parallel scalable hybrid solvers in large scale calculations

Parallel and numerically scalable hybrid solvers based on a fully algebraic coarse space correction have been theoretically studied and various advanced parallel implementations have been designed. Their parallel scalability has been initially investigated on large scale problems within the EoCoE project thanks to a close collaboration with the BSC and the integration of MaPHyS within the Alya software. This activity will further develop in the EoCoE2 project. The performance has also been assessed on PRACE Tier-0 machine within a PRACE Project Access through a collaboration with CERFACS and Laboratoire de Physique des Plasmas at Ecole Polytechnique for the calculation of plasma propulsion. A comparative parallel scalability study with the Algebraic MultiGrid from Petsc has been conducted in that framework.

6.1.1 AVCI

• Name: Adaptive vibrational configuration interaction
• Keywords: Vibrational spectra, Eigen value
• Functional Description:

  A-VCI is a theoretical vibrational spectroscopy algorithm developed to effectively reduce the number of vibrational states used in the configuration-interaction (CI) process. It constructs a nested basis for the discretization of the Hamiltonian operator inside a large CI approximation space and uses an a-posteriori error estimator (residue) to select the most relevant directions to expand the discretization space.

  The Hamiltonian operator consists of 3 operators: a harmonic oscillator sum, the potential energy surface operator and the Coriolis operators. In addition, the code can compute the intensity of eigenvectors.

  The code can handle molecules up to 10 atoms, which corresponds to solving an eigenvalue problem in a 24-dimensional space.

• Publications: hal-01310708, hal-02518243, hal-01534134, hal-02524533
• Author: Olivier Coulaud
• Contact: Olivier Coulaud
• Partner: IPREM

6.1.2 Chameleon

• Keywords: Runtime system, Task-based algorithm, Dense linear algebra, HPC, Task scheduling
• Scientific Description:

  Chameleon is part of the MORSE (Matrices Over Runtime Systems @ Exascale) project. The overall objective is to develop robust linear algebra libraries relying on innovative runtime systems that can fully benefit from the potential of those future large-scale complex machines.

  We expect advances in three directions based first on strong and closed interactions between the runtime and numerical linear algebra communities. This initial activity will then naturally expand to more focused but still joint research in both fields.

  1. Fine interaction between linear algebra and runtime systems. On parallel machines, HPC applications need to take care of data movement and consistency, which can be either explicitly managed at the level of the application itself or delegated to a runtime system. We adopt the latter approach in order to better keep up with hardware trends whose complexity is growing exponentially. One major task in this project is to define a proper interface between HPC applications and runtime systems in order to maximize productivity and expressivity. As mentioned in the next section, a widely used approach consists in abstracting the application as a DAG that the runtime system is in charge of scheduling. Scheduling such a DAG over a set of heterogeneous processing units introduces a lot of new challenges, such as predicting accurately the execution time of each type of task over each kind of unit, minimizing data transfers between memory banks, performing data prefetching, etc. Expected advances: In a nutshell, a new runtime system API will be designed to allow applications to provide scheduling hints to the runtime system and to get real-time feedback about the consequences of scheduling decisions.

  2. Runtime systems. A runtime environment is an intermediate layer between the system and the application. It provides low-level functionality not provided by the system (such as scheduling or management of the heterogeneity) and high-level features (such as performance portability). In the framework of this proposal, we will work on the scalability of runtime environment. To achieve scalability it is required to avoid all centralization. Here, the main problem is the scheduling of the tasks. In many task-based runtime environments the scheduler is centralized and becomes a bottleneck as soon as too many cores are involved. It is therefore required to distribute the scheduling decision or to compute a data distribution that impose the mapping of task using, for instance the so-called “owner-compute” rule. Expected advances: We will design runtime systems that enable an efficient and scalable use of thousands of distributed multicore nodes enhanced with accelerators.

  3. Linear algebra. Because of its central position in HPC and of the well understood structure of its algorithms, dense linear algebra has often pioneered new challenges that HPC had to face. Again, dense linear algebra has been in the vanguard of the new era of petascale computing with the design of new algorithms that can efficiently run on a multicore node with GPU accelerators. These algorithms are called “communication-avoiding” since they have been redesigned to limit the amount of communication between processing units (and between the different levels of memory hierarchy). They are expressed through Direct Acyclic Graphs (DAG) of fine-grained tasks that are dynamically scheduled. Expected advances: First, we plan to investigate the impact of these principles in the case of sparse applications (whose algorithms are slightly more complicated but often rely on dense kernels). Furthermore, both in the dense and sparse cases, the scalability on thousands of nodes is still limited, new numerical approaches need to be found. We will specifically design sparse hybrid direct/iterative methods that represent a promising approach.

  Overall end point. The overall goal of the MORSE associate team is to enable advanced numerical algorithms to be executed on a scalable unified runtime system for exploiting the full potential of future exascale machines.

• Functional Description: Chameleon is a dense linear algebra software relying on sequential task-based algorithms where sub-tasks of the overall algorithms are submitted to a Runtime system. A Runtime system such as StarPU is able to manage automatically data transfers between not shared memory area (CPUs-GPUs, distributed nodes). This kind of implementation paradigm allows to design high performing linear algebra algorithms on very different type of architecture: laptop, many-core nodes, CPUs-GPUs, multiple nodes. For example, Chameleon is able to perform a Cholesky factorization (double-precision) at 80 TFlop/s on a dense matrix of order 400 000 (i.e. 4 min 30 s).
• Release Contributions:

  Chameleon includes the following features:

  - BLAS 3, LAPACK one-sided and LAPACK norms tile algorithms - Support QUARK and StarPU runtime systems and PaRSEC since 2018 - Exploitation of homogeneous and heterogeneous platforms through the use of BLAS/LAPACK CPU kernels and cuBLAS/MAGMA CUDA kernels - Exploitation of clusters of interconnected nodes with distributed memory (using OpenMPI)

• URL: https://gitlab.inria.fr/solverstack/chameleon
• Authors: Emmanuel Agullo, Mathieu Faverge, Samuel Thibault, Florent Pruvost
• Contacts: Emmanuel Agullo, Florent Pruvost, Mathieu Faverge, Samuel Thibault
• Participants: Cédric Castagnede, Samuel Thibault, Emmanuel Agullo, Florent Pruvost, Mathieu Faverge
• Partners: Innovative Computing Laboratory (ICL), King Abdullha University of Science and Technology, University of Colorado Denver

6.1.3 Diodon

• Name: Diodon
• Keywords: Dimensionality reduction, Data analysis
• Functional Description: Most of dimension reduction methods inherited from Multivariate Data Analysis, and currently implemented as element in statistical learning for handling very large datasets (the dimension of spaces is the number of features) rely on a chain of pretreatments, a core with a SVD for low rank approximation of a given matrix, and a post-treatment for interpreting results. The costly part in computations is the SVD, which is in cubic complexity. Diodon is a list of functions and drivers which implement (i) pre-treatments, SVD and post-treatments on a large diversity of methods, (ii) random projection methods for running the SVD which permits to bypass the time limit in computing the SVD, and (iii) an implementation in C++ of the SVD with random projection at prescribed rank or precision, connected to MDS.
• URL: https://gitlab.inria.fr/afranc/diodon
• Authors: Alain Franc, Florent Pruvost, Romain Peressoni, Romain Peressoni
• Contacts: Alain Franc, Olivier Coulaud

6.1.4 DPLASMA

• Name: Distributed Parallel Linear Algebra Software for Multicore Architectures
• Keywords: Dense linear algebra, Linear algebra
• Functional Description: DPLASMA is the leading implementation of a dense linear algebra package for distributed heterogeneous systems. It is designed to deliver sustained performance for distributed systems where each node featuring multiple sockets of multicore processors, and if available, accelerators like GPUs or Intel Xeon Phi. DPLASMA achieves this objective through the state of the art PaRSEC runtime, porting the PLASMA algorithms to the distributed memory realm.
• URL: http://icl.cs.utk.edu/parsec/index.html
• Author: Mathieu Faverge
• Contact: Mathieu Faverge

6.1.5 Fabulous

• Name: Fast Accurate Block Linear krylOv Solver
• Keywords: Numerical algorithm, Block Krylov solver
• Scientific Description: Versatile and flexible numerical library that implements Block Krylov iterative schemes for the solution of linear systems of equations with multiple right-hand sides
• Functional Description: Versatile and flexible numerical library that implements Block Krylov iterative schemes for the solution of linear systems of equations with multiple right-hand sides. The library implements block variants of minimal norm residual variants with partial convergence management and spectral information recycling. The package already implements regular block-GMRES (BGMRES), Inexact Breakdown BGMRES (IB-BMGRES), Inexact Breakdown BGMRES with Deflated Restarting (IB-BGMRES-DR), Block Generalized Conjugate Residual with partial convergence management. The C++ library relies on callback mechanisms to implement the calculations (matrix-vector, dot-product, ...) that depend on the parallel data distribution selected by the user.
• URL: https://gitlab.inria.fr/solverstack/fabulous/
• Publication: hal-01067159
• Authors: Luc Giraud, Emmanuel Agullo, Gilles Marait, Cyrille Piacibello, Thomas Mijieux
• Contacts: Luc Giraud, Emmanuel Agullo
• Participants: Emmanuel Agullo, Luc Giraud, Gilles Marait, Cyrille Piacibello, Matthieu Simonin

6.1.6 MAPHYS

• Name: Massively Parallel Hybrid Solver
• Keyword: Parallel hybrid direct/iterative solution of large linear systems
• Functional Description:

  MaPHyS is a software package that implements a parallel linear solver coupling direct and iterative approaches. The underlying idea is to apply to general unstructured linear systems domain decomposition ideas developed for the solution of linear systems arising from PDEs. The interface problem, associated with the so called Schur complement system, is solved using a block preconditioner with overlap between the blocks that is referred to as Algebraic Additive Schwarz. A fully algebraic coarse space is available for symmetric positive definite problems, that insures the numerical scalability of the preconditioner.

  The parallel implementation is based on MPI+thread. Maphys relies on state-of-the art sparse and dense direct solvers.

  MaPHyS is essentially a preconditioner that can be used to speed-up the convergence of any Krylov subspace method and is coupled with the ones implemented in the Fabulous package.

• URL: https://gitlab.inria.fr/solverstack/maphys
• Publications: hal-01379227, hal-01399203
• Contacts: Luc Giraud, Emmanuel Agullo
• Participants: Emmanuel Agullo, Luc Giraud, Matthieu Kuhn, Gilles Marait, Louis Poirel

6.1.7 MAPHYS++

• Name: Massively Parallel Hybrid Solver in modern C++
• Keywords: Linear Systems Solver, Parallel computing, C++, Parallel numerical solvers
• Scientific Description: Maphys++ is a parallel linear solver for the resolution of large hollow linear systems that attempts to best combine the advantages of direct methods in terms of robustness and iterative methods in terms of memory footprint and adapted precision.
• Functional Description: MAPHYS++ is a parallel linear solver for large sparse linear systems. It implements a modern C++ interface (C++17/20), giving the user a wide range of solving methods : efficient direct solver (wrapping MUMPS, Pastix...), iterative solver (CG, GMRES...) and also allowing for a combination of those (hybrid solve using the Schur complement or directly on the original matrix, with various preconditioners). Parallelism is based on domain decomposition methods and is implemented in MPI.
• News of the Year: The redesign of the package has been completed
• URL: https://gitlab.inria.fr/solverstack/maphys/maphyspp
• Contacts: Emmanuel Agullo, Gilles Marait, Luc Giraud
• Participants: Emmanuel Agullo, Luc Giraud, Gilles Marait, Matthieu Simonin

6.1.8 StarPart

• Keywords: High performance computing, HPC, Parallel computing, Graph algorithmics, Graph, Hypergraph
• Functional Description: StarPart is a flexible and extensible framework that integrates state-of-the-art methods for graph partitioning and sparse matrix ordering. More precisely, StarPart is a framework that offers a uniform API to manipulate graph, hypergraph and mesh structures. It is designed to be easily extensible by adding new methods and to plug all these methods into a comprehensive framework. It is initially designed to provide graph partitioning and sparse matrix ordering methods, that come from sate-of-the-art software such as Metis, Scotch, Patoh, Zoltan, etc. Besides, it provides some facilities for IO, diagnostic, benchmark, visualization (VTK, SVG, ...). StarPart is the core of the MetaPart project. It is built upon the LibGraph library.
• URL: https://gitlab.inria.fr/metapart/starpart
• Contact: Aurélien Esnard
• Participant: Aurélien Esnard

6.1.9 MPICPL

• Name: MPI CouPLing
• Keywords: MPI, Coupling software
• Functional Description: MPICPL is a software library dedicated to the coupling of parallel legacy codes, that are based on the well-known MPI standard. It proposes a lightweight and comprehensive programing interface that simplifies the coupling of several MPI codes (2, 3 or more). MPICPL facilitates the deployment of these codes thanks to the mpicplrun tool and it interconnects them automatically through standard MPI inter-communicators. Moreover, it generates the universe communicator, that merges the world communicators of all coupled-codes. The coupling infrastructure is described by a simple XML file, that is just loaded by the mpicplrun tool.
• URL: https://gitlab.inria.fr/esnard/mpicpl
• Contact: Aurélien Esnard
• Participant: Aurélien Esnard

6.1.10 OptiDis

• Keywords: Dislocation dynamics simulation, Fast multipole method, Large scale, Collision
• Functional Description: OptiDis is a new code for large scale dislocation dynamics simulations. Its purpose is to simulate real life dislocation densities (up to 5.1022 dislocations/m-2) in order to understand plastic deformation and study strain hardening. The main application is to observe and understand plastic deformation of irradiated zirconium. Zirconium alloys are the first containment barrier against the dissemination of radioactive elements. More precisely, with neutron irradiated zirconium alloys we are talking about channeling mechanism, which means to stick with the reality, more than tens of thousands of induced loops, i. e. 100 million degrees of freedom in the simulation. The code is based on Numodis code developed at CEA Saclay and the ScalFMM library developed in HiePACS project. The code is written in C++ language and using the last features of C++11/14. One of the main aspects is the hybrid parallelism MPI/OpenMP that gives the software the ability to scale on large cluster while the computation load rises. In order to achieve that, we use different levels of parallelism. First of all, the simulation box is distributed over MPI processes, then we use a thinner level for threads, dividing the domain by an Octree representation. All theses parts are controlled by the ScalFMM library. On the last level, our data are stored in an adaptive structure that absorbs the dynamics of this type of simulation and manages the parallelism of tasks..
• URL: http://optidis.gforge.inria.fr/
• Publication: hal-01086371
• Authors: Olivier Coulaud, Arnaud Etcheverry, Pierre Blanchard, Arnaud Durocher
• Contact: Olivier Coulaud
• Participant: Olivier Coulaud
• Partner: CEA

6.1.11 PaStiX

• Name: Parallel Sparse matriX package
• Keywords: Linear algebra, High-performance calculation, Sparse Matrices, Linear Systems Solver, Low-Rank compression
• Scientific Description: PaStiX is based on an efficient static scheduling and memory manager, in order to solve 3D problems with more than 50 million of unknowns. The mapping and scheduling algorithm handle a combination of 1D and 2D block distributions. A dynamic scheduling can also be applied to take care of NUMA architectures while taking into account very precisely the computational costs of the BLAS 3 primitives, the communication costs and the cost of local aggregations.
• Functional Description:

  PaStiX is a scientific library that provides a high performance parallel solver for very large sparse linear systems based on block direct and block ILU(k) methods. It can handle low-rank compression techniques to reduce the computation and the memory complexity. Numerical algorithms are implemented in single or double precision (real or complex) for LLt, LDLt and LU factorization with static pivoting (for non symmetric matrices having a symmetric pattern). The PaStiX library uses the graph partitioning and sparse matrix block ordering packages Scotch or Metis.

  The PaStiX solver is suitable for any heterogeneous parallel/distributed architecture when its performance is predictable, such as clusters of multicore nodes with GPU accelerators or KNL processors. In particular, we provide a high-performance version with a low memory overhead for multicore node architectures, which fully exploits the advantage of shared memory by using an hybrid MPI-thread implementation.

  The solver also provides some low-rank compression methods to reduce the memory footprint and/or the time-to-solution.

• URL: https://gitlab.inria.fr/solverstack/pastix
• Authors: Xavier Lacoste, Pierre Ramet, Mathieu Faverge, Pascal Hénon, Tony Delarue, Esragul Korkmaz, Grégoire Pichon
• Contacts: Pierre Ramet, Mathieu Faverge
• Participants: Tony Delarue, Grégoire Pichon, Mathieu Faverge, Esragul Korkmaz, Pierre Ramet
• Partners: INP Bordeaux, Université de Bordeaux

6.1.12 pmtool

• Keywords: Scheduling, Task scheduling, StarPU, Heterogeneity, GPGPU, Performance analysis
• Functional Description: Analyse post-mortem the behavior of StarPU applications. Provide lower bounds on makespan. Study the performance of different schedulers in a simple context. Provide implementations of many scheduling algorithms from the literature
• News of the Year: Included many new algorithms, in particular online algorithms Better integration with StarPU by accepting .rec files as input
• URL: https://gitlab.inria.fr/eyrauddu/pmtool
• Publications: hal-01386174, hal-01878606
• Contact: Lionel Eyraud-Dubois
• Participant: Lionel Eyraud-Dubois

6.1.13 rotor

• Name: Re-materializing Optimally with pyTORch
• Keywords: Deep learning, Optimization, Python, GPU, Automatic differentiation
• Scientific Description:

  This software implements in PyTorch a new activation checkpointing method which allows to significantly decrease memory usage when training Deep Neural Networks with the back-propagation algorithm. Similarly to checkpointing techniques coming from the literature on Automatic Differentiation, it consists in dynamically selecting the forward activations that are saved during the training phase, and then automatically recomputing missing activations from those previously recorded. We propose an original computation model that combines two types of activation savings: either only storing the layer inputs, or recording the complete history of operations that produced the outputs (this uses more memory, but requires fewer recomputations in the backward phase), and we provide in https://hal.inria.fr/hal-02352969 an algorithm to compute the optimal computation sequence for this model.

  Our PyTorch implementation processes the entire chain, dealing with any sequential DNN whose internal layers may be arbitrarily complex and automatically executing it according to the optimal checkpointing strategy computed given a memory limit. In https://hal.inria.fr/hal-02352969, through extensive experiments, we show that our implementation consistently outperforms existing checkpoint-ing approaches for a large class of networks, image sizes and batch sizes.

• Functional Description: Allows to train very large convolutional networks on limited memory by optimally selecting which activations should be kept and which should be recomputed. This code is meant to replace the checkpoint.py utility available in pytorch, by providing more efficient rematerialization strategies. The algorithm is easier to tune: the only required parameter is the available memory, instead of the number of segments.
• Publication: hal-02352969
• Authors: Lionel Eyraud-Dubois, Olivier Beaumont, Alena Shilova, Julien Herrmann
• Contacts: Lionel Eyraud-Dubois, Olivier Beaumont, Alena Shilova
• Participants: Olivier Beaumont, Alena Shilova, Alexis Joly, Lionel Eyraud-Dubois, Julien Herrmann

6.1.14 ScalFMM

• Name: Scalable Fast Multipole Method
• Keywords: N-body, Fast multipole method, Parallelism, MPI, OpenMP
• Scientific Description:

  ScalFMM is a software library to simulate N-body interactions using the Fast Multipole Method. The library offers two methods to compute interactions between bodies when the potential decays like 1/r. The first method is the classical FMM based on spherical harmonic expansions and the second is the Black-Box method which is an independent kernel formulation (introduced by E. Darve @ Stanford). With this method, we can now easily add new non oscillatory kernels in our library. For the classical method, two approaches are used to decrease the complexity of the operators. We consider either matrix formulation that allows us to use BLAS routines or rotation matrix to speed up the M2L operator.

  ScalFMM intends to offer all the functionalities needed to perform large parallel simulations while enabling an easy customization of the simulation components: kernels, particles and cells. It works in parallel in a shared/distributed memory model using OpenMP and MPI. The software architecture has been designed with two major objectives: being easy to maintain and easy to understand. There is two main parts:

  the management of the octree and the parallelization of the method the kernels. This new architecture allow us to easily add new FMM algorithm or kernels and new paradigm of parallelization.

• Functional Description: Compute N-body interactions using the Fast Multipole Method for large number of objects
• URL: https://gitlab.inria.fr/solverstack/ScalFMM
• Authors: Bramas Bérenger, Olivier Coulaud
• Contact: Olivier Coulaud
• Participants: Bramas Bérenger, Olivier Coulaud, Pierre Estérie

6.1.15 VITE

• Name: Visual Trace Explorer
• Keywords: Visualization, Execution trace
• Functional Description: ViTE is a trace explorer. It is a tool made to visualize execution traces of large parallel programs. It supports Pajé, a trace format created by Inria Grenoble, and OTF and OTF2 formats, developed by the University of Dresden and allows the programmer a simpler way to analyse, debug and/or profile large parallel applications.
• URL: http://vite.gforge.inria.fr/
• Authors: Mathieu Faverge, Nicolas Richart, Cédric Augonnet
• Contact: Mathieu Faverge
• Participant: Mathieu Faverge

6.1.16 PlaFRIM

• Name: Plateforme Fédérative pour la Recherche en Informatique et Mathématiques
• Keywords: High-Performance Computing, Hardware platform
• Functional Description:

  PlaFRIM is an experimental platform for research in modeling, simulations and high performance computing. This platform has been set up from 2009 under the leadership of Inria Bordeaux Sud-Ouest in collaboration with computer science and mathematics laboratories, respectively Labri and IMB with a strong support in the region Aquitaine.

  It aggregates different kinds of computational resources for research and development purposes. The latest technologies in terms of processors, memories and architecture are added when they are available on the market. It is now more than 1,000 cores (excluding GPU and Xeon Phi ) that are available for all research teams of Inria Bordeaux, Labri and IMB. This computer is in particular used by all the engineers who work in HiePACS and are advised by F. Rue from the SED.

• URL: https://www.plafrim.fr/en/home/
• Contact: Olivier Coulaud

7.1.1 Exploring variable accuracy storage through lossy compression techniques in numerical linear algebra: a first application to flexible GMRES

In the context of the Inria International Lab JLESC we have an ongoing collaboration with Argonne National Laboratory on the use of agnostic compression techniques to reduce the memory footprint of iterative linear solvers. Large scale applications running on HPC systems often require a substantial amount of memory and can have a large data movement overhead. Lossy data compression techniques can reduce the size of the data and associated communication cost, but the effect of the loss of accuracy on the numerical algorithm can be hard to predict. In this work we examine the FGMRES algorithm, which requires the storage of a basis for the search space and another one for the space spanned by the residuals. We show that the vectors spanning this search space can be compressed by looking at the combination of FGMRES and compression in the context of inexact Krylov subspace methods. This allows us to derive a bound on the normwise relative compression error in each iteration. We use this bound to formulate a number of different practical compression strategies, and validate and compare them through numerical experiments. We refer the reader to 34 for a detailed presentation of this work.

7.1.2 A block minimum residual norm subspace linear solver for sequences of multiple left and right-hand side linear systems

We are concerned with the iterative solution of linear systems with multiple right-hand sides available one group after another, including the case where there are massive number (like tens of thousands) of right-hand sides associated with a single matrix so that all of them cannot be solved at once but rather need to be split into chunks of possible variable sizes. For such sequences of linear systems with multiple left and right-hand sides, we develop a new recycling block generalized conjugate residual method with inner orthogonalization and inexact breakdown (IB-BGCRO-DR), which glues subspace recycling technique in GCRO-DR [SIAM J. Sci. Comput., 28(5) (2006), pp 1651,1674] and inexact breakdown mechanism in IB-BGMRES [Linear Algebra Appl., 419 (2006), pp. 265,285] to guarantee this new algorithm could reuse spectral information for subsequent cycles as well as for the remaining linear systems to be solved. Related variant IB-BFGCRO-DR that suits for flexible preconditioning is devised to cope with constraints on some applications while also enabling mixed-precision calculation, which provides advantages in speed and memory usage over double precision as well as in perspective of emerging computing units such as the GPUs. Besides, we also discuss why/ how many possible choices are available when building recycling subspace as well as how to exploit the inexact breakdown mechanism for realizing the flexibility of search space expansion policies and monitoring individual convergence thresholds for each single right-hand side. As a side effect one also illustrates that this method can be applied to constant/ slowly-varying left-hand side. Finally we demonstrate the numerical and computational benefits of combining these ideas in such algorithms on a set of simple academic examples with a sequence of right-hand sides.

A scientific report should appear shortly that will detailed this work. Furthermore, a C++ implementation in the Fabulous package is also an ongoing work.

7.1.3 2D Static Resource Allocation for Compressed Linear Algebra and Communication Constraints

In 24, we consider the design of static resource allocation problems for irregular distributed parallel applications. More precisely, we focus on two classical tiled linear algebra kernels: the Matrix Multiplication (MM) and the LU decomposition (LU) algorithms on large linear systems. In the context of parallel distributed platforms, data exchanges can dramatically degrade the performance of linear algebra kernels and in this context, compression techniques such as Block Low Rank (BLR) compression techniques are good candidates both for limiting data storage on each processor and data exchanges between processors. On the other hand, the use of BLR representation makes the static allocation problem of tiles to processors more complex. Indeed, the load associated to each tile depends on its compression factor, which induces an heterogeneous load balancing problem. In turn, solving this load balancing problem optimally might lead to complex allocation schemes, where the tiles allocated to a given processor are scattered all over the matrix. This in turn induces communication costs, since matrix multiplication and LU decompositions heavily rely on broadcasting operations along rows and columns of processors, so that the communication volume is minimized when the maximal number of different processors on any row and column is minimized. In the fully homogeneous case, 2D Block Cyclic (BC) allocation solves both load balancing and communication minimization issues simultaneously , but it might lead to bad load balancing in the heterogeneous case. Our goal in this paper is to propose data allocation schemes dedicated to BLR format and to prove that it is possible to obtain good performance on makespan when simultaneously balancing the load and minimizing the maximal number of different processor in any row or column.

7.1.4 On soft errors in the Conjugate Gradient method: sensitivity and robust numerical detection

The conjugate gradient (CG) method is the most widely used iterative scheme for the solution of large sparse systems of linear equations when the matrix is symmetric positive definite. Although more than sixty year old, it is still a serious candidate for extreme-scale computations on large computing platforms. On the technological side, the continuous shrinking of transistor geometry and the increasing complexity of these devices affect dramatically their sensitivity to natural radiation, and thus diminish their reliability. One of the most common effects produced by natural radiation is the single event upset which consists in a bit-flip in a memory cell producing unexpected results at application level. Consequently, the future extreme scale computing facilities will be more prone to errors of any kind, including bit-flips, during their calculations. These numerical and technological observations are the main motivations for this work, where we first investigate through extensive numerical experiments the sensitivity of CG to bit-flips in its main computationally intensive kernels, namely the matrix-vector product and the preconditionner application. We further propose numerical criteria to detect the occurrence of such soft errors and assess their robustness through extensive numerical experiments.

We have been working on the revision of this work that has been eventually published in 15; a complementary study on persistent faults is detailed in  35.

7.1.5 Recent Developments Around the Block Low-Rank PaStiX Solver

Recent works in sparse direct solvers have multiplied the solutions to exploit data-sparsity additionally to sparse structure in these solvers. Among these solution, the PaStiX solver exploits block low-rank structures to reduce both its memory consumption and time to solution. In this talk, we will discuss recent changes made to the solver in this context such as the study of suitable low-rank compression kernels, adapted ordering heuristics, or scheduling strategies through the use of runtime systems. Performance results of the latest release including the presented features will be shown and discussed.

This work has been presented at the international conference SIAM PP 2020 33.

7.1.6 Deciding Non-Compressible Blocks in Sparse Direct Solvers using Incomplete Factorization

Low-rank compression techniques are very promising for reducing memory footprint and execution time on a large spectrum of linear solvers. Sparse direct supernodal approaches are one these techniques. However, despite providing a very good scalability and reducing the memory footprint, they suffer from an important flops overhead in their unstructured low-rank updates. As a consequence, the execution time is not improved as expected.

In this paper, we study a solution to improve low-rank compression techniques in sparse supernodal solvers. The proposed method tackles the overprice of the low-rank updates by identifying the blocks that have poor compression rates. We show that block incomplete LU factorization, thanks to the block fill-in levels, allows us to identify most of these non-compressible blocks at low cost. This identification enables us to postpone the low-rank compression step to trade small extra memory consumption for a better time to solution. The solution is validated within the PaStiX library with a large set of application matrices. It demonstrates sequential and multi-threaded speedup up to $84\%$, for small memory overhead of less than $3\%$ with respect to the original version.

This work will be submitted at the international conference EuroPar 2021.

7.2.1 Material physics

The Adaptive Vibrational Configuration Interaction (A-VCI) algorithm is an iterative process that computes the anharmonic spectrum of a molecule using nested bases to discretize the Hamiltonian operator in high dimension. For large molecular systems, the size of the discretization space, the computation time and the memory consumption become prohibitive especially when are looking eigenvalues in the middle of the spectra. It is therefore necessary to develop new methods to further limit the number of basis functions.

To overcome this issues, we have worked this year in two direction.

• Most of the time, the interpretation of an experimental infrared spectrum does not require the calculation of all eigenvalues but only those corresponding to vibrational states with significant intensity. In 20 a technique that uses infrared intensities is introduced to select a subset of eigenvalues to be precisely calculated. Thus, we build smaller nested bases and reduce both the memory footprint and the computational time. We validate the advantages of this new approach on a well-studied 7-atom molecular system (C2H4O), and we apply it on a larger 10-atom molecule (C4H4N2).
• We have adapted the FEAST algorithm to search for eigenvalue in an interval to the tensor formalism and more particularly to the tensor train (TT) format when both operators and eigenvectors are written in TT format. The method uses the contour integral theory to construct the projector of the space generated by the target eigenvectors. The main problem is to construct the projector and to control its rank, in order to quickly compute a solution. We have proposed an orthogonalization scheme based on the gram matrix and the preliminary results obtained are promising on small molecules (dimensions 3 and 6). An article is in progress.

7.2.2 Metabarcoding

This year, we focused mainly on the work of comparing point clouds obtained by multidimensional scaling calculations. Our goal is to find a way to automatically compare these clouds without having to look at them manually in order to judge whether or not they have the same shape. To do this, we took into account Hausdorff's distance. However this metric had several problems like the presence of outliers i.e. few points that are very far away but affect the distance by lot, different orientations of the cloud shape. We have proposed an algorithm that overcomes these difficulties and gives very unsuccessful results. To improve these performances, we now compute distances in larger spaces. That led to issues with the cost of alignment which rise exponentially with the number of dimensions studied. We have proposed a heuristic that allows us to compare the shapes after passing them through a process that have the same output regardless of the symmetries present. A report is being written.

We are involved in the ADT Gordon ((partners: TADAAM (coordinator), STORM, HiePACS, PLEIADE). The objectives of this ADT is to scale our sollver stack on a PLEIADE dimensioning metabarcoding application (multidimensional scaling method). Our goal is to be able to handle a problem leading to a distance matrix around 100 million individuals. Our contribution concerns the the scalability of the multidimensional scaling method and more particulary the random projection methods to speed up the SVD solver. Experiments on occigen plateform has allowed us to show that the solver stack was able to solve efficiently a large problem up to one million individuals in less than 22 minutes on 100 nodes. This has highlighted that for these problem sizes the management of I/O, inputs and outputs with the disks, becomes critical and dominates calculation times.

Concerning the use of tensor formalism for data analysis, we worked on two aspects in collaboration with EPC PLEIADE (A. Franc). Firstly, a methodology was set up to analyze the structured data of the Malabar project. These data are genetic data collected in the Arcachon bay. The frequencies of these genetic sequences were classified according to their species, zone, time and position in the water column of collection. On the frequency tensor, the Tucker decomposition without or with the positivity constraint of the tensor was applied and made it possible to review the techniques for extracting the relevant information. In a second step, we were interested in the Correspondance Analysis and its geometric interpretation (of point clouds) from frequency matrices and their studies. The analysis of point clouds is possible thanks to a linear relationship existing between the point clouds. We have studied how to extend this relationship to three point clouds, by applying some properties developed in the context of Tucker's hierarchy. An article is in progress.

7.2.3 Co-design for scalable algorithms in scientific applications

7.3.1 Memory optimization

Training Deep Neural Networks is known to be an expensive operation, both in terms of computational cost and memory load. Indeed, during training, all intermediate layer outputs (called activations) computed during the forward phase must be stored until the corresponding gradient has been computed in the backward phase. These memory requirements sometimes prevent to consider larger batch sizes and deeper networks, so that they can limit both convergence speed and accuracy.

Recent works have proposed to offload some of the computed forward activations from the memory of the GPU to the memory of the CPU. This requires to determine which activations should be offloaded and when these transfers from and to the memory of the GPU should take place. In 23, We prove that this problem is NP-hard in the strong sense, and we propose two heuristics based on relaxations of the problem. We perform extensive experimental evaluation on standard Deep Neural Networks. We compare the performance of our heuristics against previous approaches from the literature, showing that they achieve much better performance in a wide variety of situations.

7.3.2 Optimization of Pipelined Model Parallelism

In 38 we consider the complexity of the optimization problems induced by the use of pipelined model parallelism for the he 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, to analyze the complexity of the associated throughput optimization problem under memory constraints and to show that it is possible to formalize this optimization problem as an Integer Linear Program (ILP). In 37, 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.

7.4.1 Improving mapping for sparse direct solvers: A trade-off between data locality and load balancing

In order to express parallelism, parallel sparse direct solvers take advantage of the elimination tree to exhibit tree-shaped task graphs, where nodes represent computational tasks and edges represent data dependencies. One of the pre-processing stages of sparse direct solvers consists of mapping computational resources (processors) to these tasks. The objective is to minimize the factorization time by exhibiting good data locality and load balancing. The proportional mapping technique is a widely used approach to solve this resource-allocation problem. It achieves good data locality by assigning the same processors to large parts of the elimination tree. However, it may limit load balancing in some cases. In this paper, we propose a dynamic mapping algorithm based on proportional mapping. This new approach, named Steal, relaxes the data locality criterion to improve load balancing. In order to validate the newly introduced method, we perform extensive experiments on the PaStiX sparse direct solver. It demonstrates that our algorithm enables better static scheduling of the numerical factorization while keeping good data locality.

This work has been presented at the international conference EuroPar 2020 29.

7.4.2 Efficient Ordering of Kernel Submission on GPUs

In distributed memory systems, it is paramount to develop strategies to overlap the data transfers between memory nodes with the computations in order to exploit their full potential. In 28, we consider the problem of determining the order of data transfers between two memory nodes for a set of independent tasks with the objective of minimizing the makespan. We prove that, with limited memory capacity, the problem of obtaining the optimal data transfer order is NP-complete. We propose several heuristics to determine this order and discuss the conditions that might be favorable to different heuristics. We analyze our heuristics on traces obtained by running two molecular chemistry kernels, namely, Hartree‚Fock (HF) and Coupled Cluster Singles Doubles (CCSD), on 10 nodes of an HPC system. Our results show that some of our heuristics achieve significant overlap for moderate memory capacities and resulting in makespans that are very close to the lower bound.

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 40, 27, 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%.

7.4.3 Scheduling Tasks on Two Types of Resources

We study in 17 the problem of executing an application represented by a precedence task graph on a parallel machine composed of standard computing cores and accelerators. Contrary to most existing approaches, we distinguish the allocation and the scheduling phases and we mainly focus on the allocation part of the problem: choose the most appropriate type of computing unit for each task. We address both off-line and on-line settings and design generic scheduling approaches. In the first case, we establish strong lower bounds on the worst-case performance of a known approach based on Linear Programming for solving the allocation problem. Then, we refine the scheduling phase and we replace the greedy List Scheduling policy used in this approach by a better ordering of the tasks. Although this modification leads to the same approximability guarantees, it performs much better in practice. We also extend this algorithm to more types of computing units, achieving an approximation ratio which depends on the number of different types. In the on-line case, we assume that the tasks arrive in any, not known in advance, order which respects the precedence relations and the scheduler has to take irrevocable decisions about their allocation and execution. In this setting, we propose the first on-line scheduling algorithm which takes into account precedences. Our algorithm is based on adequate rules for selecting the type of processor where to allocate the tasks and it achieves a constant factor approximation guarantee if the ratio of the number of CPUs over the number of GPUs is bounded. Finally, all the previous algorithms for hybrid architectures have been experimented , on a large set of common benchmarks that we made available for the community. These simulations assess the good practical behavior of the algorithms with respect to the state-of-the-art solutions, whenever these exist, or baseline algorithms.

7.4.4 Geometric Deep Reinforcement Learning for Dynamic DAG Scheduling

Along a slightly different direction, we consider in 30 the use of reinforcement learning to help to design efficient dynamic schedulers to be used in runtime systems such as StarPU. In practice, it is quite common to face combinatorial optimization problems which contain uncertainty along with non-determinism and dynamicity. These three properties call for appropriate algorithms; reinforcement learning (RL) is dealing with them in a very natural way. Today, despite some efforts, most real-life combinatorial optimization problems remain out of the reach of reinforcement learning algorithms. In this paper, we propose a reinforcement learning approach to solve a realistic scheduling problem, and apply it to an algorithm commonly executed in the high performance computing community, the Cholesky factorization. On the contrary to static scheduling, where tasks are assigned to processors in a predetermined ordering before the beginning of the parallel execution, our method is dynamic: task allocations and their execution ordering are decided at runtime, based on the system state and unexpected events, which allows much more flexibility. To do so, our algorithm uses graph neural networks in combination with an actor-critic algorithm (A2C) to build an adaptive representation of the problem on the fly. We show that this approach is competitive with state-of-the-art heuristics used in high-performance computing runtime systems. Moreover, our algorithm does not require an explicit model of the environment, but we demonstrate that extra knowledge can easily be incorporated and improves performance. We also exhibit key properties provided by this RL approach, and study its transfer abilities to other instances.

7.4.5 Approximation Algorithm for Estimating Distances in Distributed Virtual Environments

We are also interested in the possibility of performing extra (redundant) computations in order to save messages. This possibility might be of interest, for instance, in the context of energy savings, and it is crucial in contexts such as on-line games. In 22, we consider the issue of guaranteeing properties in Distributed Virtual Environments (DVEs) without a server and without global knowledge of the system state and therefore only by exchanging messages. This issue is particularly relevant in the case of online games, that operate in a fully distributed framework and for which network resources such as bandwidth are the critical resources. In the context of games, players typically need to know the distance between their character and other characters, at least approximately. Players all share the same position estimation algorithm but, in general, do not know the current positions of others. We provide a synchronized distributed algorithm Alc to guarantee, at any time, that the estimated distance d est between any pair of characters A and B is always a (1 + $ϵ$) approximation of the current distance. Our result is twofold: (1) we prove that if characters move randomly on a d-dimensional grid, or follow a random continuous movement on up to three dimensions, the number of messages of Alc is optimal up to a constant factor; (2) in a more practical setting, we also observe that the number of messages of Alc for actual game traces is much less than the standard algorithm sending actual positions at a given frequency.

7.4.6 A Makespan Lower Bound for the Scheduling of the Tiled Cholesky Factorization based on ALAP Schedule

In 25, we consider the theoretical problem of deriving strong bounds on the running time of Cholesky factorization, performed on homogeneous (GPUs or CPUs) resources. Due to the advent of multicore architectures and massive parallelism, the tiled Cholesky factorization algorithm has recently received plenty of attention and is often referenced by practitioners as a case study. It is also implemented in mainstream dense linear algebra libraries and is used as a testbed for runtime systems. However, we note that theoretical study of the parallelism of this algorithm is currently lacking. In this paper, we present new theoretical results about the tiled Cholesky factorization in the context of a parallel homogeneous model without communication costs. Based on the relative costs of involved kernels, we prove that only two different situations must be considered, typically corresponding to CPUs and GPUs. By a careful analysis on the number of tasks of each type that run simultaneously in the ALAP (As Late As Possible) schedule without resource limitation, we are able to determine precisely the number of busy processors at any time (as degree 2 polynomials). We then use this information to find a closed form formula for the minimum time to schedule a tiled Cholesky factorization of size n on P processors. We show that this bound outperforms classical bounds from the literature. We also prove that ALAP(P), an ALAP-based schedule where the number of resources is limited to P , has a makespan extremely close to the lower bound, thus proving both the effectiveness of ALAP(P) schedule and of the lower bound on the makespan.

7.4.7 Performance Analysis and Optimality Results for Data-Locality Aware Tasks Scheduling with Replicated Inputs

In 18, we consider the influence on data-locality of the replication of data files, as automatically performed by Distributed File Systems such as HDFS. Replication of data files, as automatically performed by Distributed File Systems such as HDFS, is known to have a crucial impact on data locality in addition to system fault tolerance. Indeed, intuitively, having more replicas of the same input file gives more opportunities for this task to be processed locally, i.e. without any input file transfer. Given the practical importance of this problem, a vast literature has been proposed to schedule tasks, based on a random placement of replicated input files. Our goal in this paper is to study the performance of these algorithms, both in terms of makespan minimization (minimize the completion time of the last task when non-local processing is forbidden) and communication minimization (minimize the number of non-local tasks when no idle time on resources is allowed). In the case of homogenous tasks, we are able to prove, using models based on "balls into bins" and "power of two choices" problems, that the well known good behavior of classical strategies can be theoretically grounded. Going further, we even establish that it is possible, using semi-matchings theory, to find the optimal solution in very small time. We also use known graph-orientation results to prove that this optimal solution is indeed near-perfect with strong probability. In the more general case of heterogeneous tasks, we propose heuristics solutions both in the clairvoyant and non-clairvoyant cases (i.e. task length is known in advance or not), and we evaluate them through simulations, using actual traces of a Hadoop cluster.

8.1.1 Inria International Labs

There is an ongoing reasearch activity with Argonne National Laboratory in the framework of the JLESC International Lab, through a postdoc funded by the DPI, namely Nick Schenkels, who work on data compression techniques in Krylov methods for the solution of large linear systems. The objective is to use agnostic compressor developped at Argonne to compress the basis involved in Krylov methods that have a large memory footprint. The challenge is to design algorithm that reduce the memory consumption, hence the energy, while preserving the numerical convergence of the numerical technique. We refer to 34 for a detailed description of the work.

8.1.2 Inria associate team not involved in an IIL

8.2.1 FP7 & H2020 Projects

8.3.1 ANR

8.3.2 FUI

8.3.3 Inria Project Labs

9.1.1 Scientific events: organisation

9.1.2 Journal

9.1.3 Scientific expertise

• Olivier Beaumont acted as expert for 2020 FET Open Evaluation Committee.
• Luc Giraud is member of the board on Modelization, Simulation and data analysis of the Competitiveness Cluster for Aeronautics, Space and Embedded Systems. He is also member of the scientific council of the ONERA Lab LMA2S (Laboratoire de Mathématiques Appliquées à l'Aéronautique et au Spatial).
• Pierre Ramet is Scientific Advisor at the CEA-DAM CESTA.
• Guillaume Sylvand is Expert in Numerical Simulation and HPC at Airbus.

9.1.4 Research administration

• P. Ramet is the head of the SATANAS (Supports and Algorithms for High Performance Numerical Applications) team from LaBRI UMR CNRS 5800.

9.2.1 Teaching

• Undergraduate level/Licence:
  • A. Esnard: System programming 36h, Computer architecture 40h, Network 23h, C programming 35h at Bordeaux University. He is also responsible for the second year of the computer science degree (L2 Informatique), which involves managing about 200 students each year.
  • M. Faverge: Programming environment 26h, Numerical algorithmic 40h, C projects 25h at Bordeaux INP (ENSEIRB-MatMeca).
  • A. Guermouche: System programming 36h at Bordeaux University.
  • P. Ramet: System programming 24h, Databases 32h, Object programming 48h, Distributed programming 16h, Cryptography 16h, Introduction to AI Deep Learning and Data Analytics 16h at Bordeaux University.
• Post graduate level/Master:
  • E. Agullo: Operating systems 24h at Bordeaux University ; Dense linear algebra kernels 8h, Numerical algorithms 30h at Bordeaux INP (ENSEIRB-MatMeca).
  • O. Coulaud: Paradigms for parallel computing 8h, Introduction to Tensor methods 4h at Bordeaux INP (ENSEIRB-MatMeca).
  • A. Esnard: Network management 27h, Network security 27h at Bordeaux University; Programming distributed applications 35h at Bordeaux INP (ENSEIRB-MatMeca).
  • L. Eyraud-Dubois and Olivier Beaumont: Approximation and BigData 24h at Bordeaux University.
  • M. Faverge: System programming 72h, Linear Algebra for high Performance Computing 13h at Bordeaux INP (ENSEIRB-MatMeca). He is also in charge of the master 2 internship for the Computer Science department at Bordeaux INP (ENSEIRB-MatMeca). Starting in September, he is in charge with Raymond Namyst of the High Performance Computing - High Performance Data Analytics option at ENSEIRB-MatMeca. This is a common training curriculum between the Computer Science and MatMeca departments at Bordeaux INP and with Bordeaux University in the context of the Computer Science Research Master.
  • Alena Shilova and Olivier Beaumont: Deep Learning Frameworks, at Bordeaux INP (ENSEIRB-MatMeca), 20h.
  • Olivier Beaumont, Sketching and Streaming Algorithms, ENS Lyon, 8h
  • L. Giraud: Introduction to intensive computing and related programming tools 30h, INSA Toulouse; On mathematical tools for numerical simulations 10h, ENSEEIHT Toulouse.
  • A. Guermouche: Network management 92h, Network security 64h, Operating system 24h at Bordeaux University.
  • P. Ramet: Cryptography 20h and Numerical algorithmic 40h at Bordeaux INP (ENSEIRB-Matmeca).
• High School teachers:
  • A. Esnard, M. Faverge, and A. Guermouche participated to the training of the High School teachers (DIU Enseigner l'Informatique au Lycée) in computer science for the new computer science program starting in September 2019.

9.2.2 Supervision

• PhD in progress: Tobias Castanet; Replication algorithms for multi-player virtual worlds; started Sep. 2019; O. Beaumont, N. Hanusse (LaBRI), C. Travers (Bordeaux INP - LaBRI).
• PhD in progress: Marek Felsoci; Fast solvers for high-frequency aeroacoustics; started Oct. 2019; G. Sylvand, E. Agullo.
• PhD in progress: Martina Iannacito; Linear solvers in tensorial format for high dimensional problems; started Oct 2019; O. Coulaud, L. Giraud.
• PhD in progress: Esragul Korkmaz; Sparse linear solver and hierachical matrices; started Nov. 2018; M. Faverge, P. Ramet.
• PhD in progress: Romain Peressoni; Fast multidimensional scaling method for the study of biodiversity; started Oct 2019; E. Agullo, O. Coulaud, A. Franc (PLEIADE)
• PhD in progress: Alena Shilova; Scheduling for deep learning applications; started Oct. 2018; L. Eyraud-Dubois, O. Beaumont.
• PhD in progress: Nicolas Venkovic; Domain decomposition techniques for the solution of stochastics elliptic PDEs; started Nov. 2018; L. Giraud, P. Mycek (Cerfacs).
• PhD in progress: Mathieu Vérité; Static allocation algorithms for scheduling High-Performance applications; started Sept. 2019; L. Eyraud-Dubois, O. Beaumont.
• PhD in progress: Yanfei Xiang; Solution of large linear systems with massive numbers of right-hand sides. Started Nov. 2019; L. Giraud, P. Mycek (Cerfacs).

9.2.3 Juries

• Clément Mommessin, “Efficient Management of Resources in Heterogeneous Platforms"; referees: Anne Benoit and Krzysztof Rzadca; members: Olivier Beaumont, Anne Benoit, Noel de Palma, Giorgio Lucarelli, Yanick Ngoko, Krzysztof Rzadca and Denis Trystram; Université de Grenoble, December 11, 2020.

• Valentin Le Fevre, “Resilient scheduling algorithms for large-scale platforms"; referees: Henri Casanova and Rami Mehlem; members: Olivier Beaumont, Anne Benoit, Henri Casanova, Amina Guermouche, Rami Mehlem and Yves Robert; ENS Lyon, June 18, 2020.

9.2.4 Interventions

In the framework of the "Digital Career Week", Olivier Beaumont met high school students (with the NSI option) from the Lycée de la Mer (Gujan Mestras) for about two hours.

International journals

• 15 article EmmanuelE. Agullo, SiegfriedS. Cools, EmrullahE. Fatih-Yetkin, LucL. Giraud, NickN. Schenkels and WimW. Vanroose. On soft errors in the conjugate gradient method: sensitivity and robust numerical detection SIAM Journal on Scientific Computing 42 6 November 2020
  HAL DOI back to text
• 16 articleBenjaminB. Alzaix, LucL. Giraud, BastiaanB. Michielsen and Jean-RenéJ.-R. Poirier. A Plane Wave Scattering Dedicated Integral EquationIEEE Transactions on Antennas and PropagationFebruary 2020, 1-10
  HALDOI
• 17 article OlivierO. Beaumont, Louis-ClaudeL.-C. Canon, LionelL. Eyraud-Dubois, GiorgioG. Lucarelli, LorisL. Marchal, ClementC. Mommessin, BertrandB. Simon and DenisD. Trystram. Scheduling on Two Types of Resources: a Survey ACM Computing Surveys 53 3 May 2020
  HAL DOI back to text
• 18 articleOlivierO. Beaumont, ThomasT. Lambert, LorisL. Marchal and BastienB. Thomas. Performance Analysis and Optimality Results for Data-Locality Aware Tasks Scheduling with Replicated InputsFuture Generation Computer Systems111October 2020, 582-598
  HALDOIback to text
• 19 article TommasoT. Benacchio, LucaL. Bonaventura, MircoM. Altenbernd, Chris DC. Cantwell, Peter DP. Düben, MikeM. Gillard, LucL. Giraud, DominikD. Göddeke, ErwanE. Raffin, KeitaK. Teranishi and NilsN. Wedi. Resilience and fault tolerance in high-performance computing for numerical weather and climate prediction International Journal of High Performance Computing Applications February 2021
  HAL DOI
• 20 article VincentV. Le Bris, MarcM. Odunlami, DidierD. Bégué, IsabelleI. Baraille and OlivierO. Coulaud. Using computed infrared intensities for the reduction of vibrational configuration interaction bases Physical Chemistry Chemical Physics 2020
  HAL DOI back to text
• 21 articleJean-RenéJ.-R. Poirier, OlivierO. Coulaud and OguzO. Kaya. Fast BEM Solution for 2-D Scattering Problems Using Quantized Tensor-Train FormatIEEE Transactions on Magnetics563March 2020, 1-4
  HALDOIback to text

International peer-reviewed conferences

• 22 inproceedings OlivierO. Beaumont, TobiasT. Castanet, NicolasN. Hanusse and CorentinC. Travers. Approximation Algorithm for Estimating Distances in Distributed Virtual Environments Euro-Par 2020: Parallel Processing Euro-Par 2020 - 26th International European Conference on Parallel and Distributed Computing Lecture Notes in Computer Science 12247 Warsaw / Virtual, Poland LaBRI - Laboratoire Bordelais de Recherche en Informatique; Inria Bordeaux Sud-Ouest; CNRS LaBRI; Bordeaux INP https://2020.euro-par.org/ February 2020
  HAL DOI back to text
• 23 inproceedingsOlivierO. Beaumont, LionelL. Eyraud-Dubois and AlenaA. Shilova. Optimal GPU-CPU Offloading Strategies for Deep Neural Network TrainingEuro-Par 2020 - 26th International Conference on Parallel and Distributed ComputingEuro-Par 2020: Parallel Processing12247Warsaw / Virtual, Polandhttps://2020.euro-par.org/August 2020, 151-166
  HALDOIback to text
• 24 inproceedings OlivierO. Beaumont, LionelL. Eyraud-Dubois and MathieuM. Verite. 2D Static Resource Allocation for Compressed Linear Algebra and Communication Constraints HIPC 2020: 27th IEEE International Conference on High Performance Computing, Data, and Analytics Proceedings of the 27th IEEE International Conference on High Performance Computing, Data, and Analytics (virtual), India December 2020
  HAL back to text
• 25 inproceedings OlivierO. Beaumont, JulienJ. Langou, WillyW. Quach and AlenaA. Shilova. A Makespan Lower Bound for the Scheduling of the Tiled Cholesky Factorization based on ALAP Schedule EuroPar 2020 Proceedings EuroPar 2020 - 26th International European Conference on Parallel and Distributed Computing Proceedings of EuroPar 2020 Warsaw / Virtual, Poland 2020.euro-par.org August 2020
  HAL back to text
• 26 inproceedingsRocíoR. Carratalá-Sáez, MathieuM. Faverge, GrégoireG. Pichon, GuillaumeG. Sylvand and Enrique SE. Quintana-Ortí. Tiled Algorithms for Efficient Task-Parallel H-Matrix SolversPDSEC 2020 - 21st IEEE International Workshop on Parallel and Distributed Scientific and Engineering ComputingNews Orleans, United StatesMay 2020, 1-10
  HAL
• 27 inproceedings LionelL. Eyraud-Dubois and CristianaC. Bentes. Algorithms for Preemptive Co-scheduling of Kernels on GPUs HiPC 2020 : 27th IEEE International Conference on High Performance Computing, Data, and Analytics Pune / Virtual, India December 2020
  HAL back to text
• 28 inproceedings LionelL. Eyraud-Dubois and SurajS. Kumar. Analysis of a List Scheduling Algorithm for Task Graphs on Two Types of Resources IPDPS 2020 - 34th IEEE International Parallel and Distributed Procesing Symposium New Orleans / Virtual, United States May 2020
  HAL back to text
• 29 inproceedingsChangjiangC. Gou, AliA. Al Zoobi, AnneA. Benoit, MathieuM. Faverge, LorisL. Marchal, GrégoireG. Pichon and PierreP. Ramet. Improving mapping for sparse direct solvers: A trade-off between data locality and load balancingEuroPar 2020 - 26th International European Conference on Parallel and Distributed ComputingWarsaw / Virtual, PolandAugust 2020, 1-16
  HALback to text
• 30 inproceedings NathanN. Grinsztajn, OlivierO. Beaumont, EmmanuelE. Jeannot and PhilippeP. Preux. Geometric Deep Reinforcement Learning for Dynamic DAG Scheduling IEEE SSCI 2020 - Symposium Series on Computational Intelligence SSCI 2020 proceedings Canberra / Virtual, Australia December 2020
  HAL back to text

Conferences without proceedings

• 31 inproceedings Mohamed AnwarM. Abouabdallah, OlivierO. Coulaud, Alain A.A. Franc and NathalieN. Peyrard. Statistical learning for OTUs identification ISEC 2020 - International Statistical Ecology Conference Sydney / Virtual, Australia June 2020
  HAL
• 32 inproceedings RocíoR. Carratalá-Sáez, MathieuM. Faverge, GrégoireG. Pichon, Enrique SalvadorE. Quintana-Ortí and GuillaumeG. Sylvand. Exploiting Generic Tiled Algorithms Toward Scalable H-Matrices Factorizations on Top of Runtime Systems SIAM PP20 - SIAM Conference on Parallel Processing for Scientific Computing Seattle, United States February 2020
  HAL
• 33 inproceedings GrégoireG. Pichon, MathieuM. Faverge and PierreP. Ramet. Recent Developments Around the Block Low-Rank PaStiX Solver PP 2020 - SIAM Conference on Parallel Processing for Scientific Computing Seattle, United States https://www.siam.org/conferences/cm/conference/pp20 February 2020
  HAL back to text

Reports & preprints

• 34 report EmmanuelE. Agullo, FranckF. Cappello, ShengS. Di, LucL. Giraud, XinX. Liang and NickN. Schenkels. Exploring variable accuracy storage through lossy compression techniques in numerical linear algebra: a first application to flexible GMRES Inria Bordeaux Sud-Ouest May 2020
  HAL back to text back to text
• 35 report EmmanuelE. Agullo, SiegfriedS. Cools, EmrullahE. Fatih-Yetkin, LucL. Giraud, NickN. Schenkels and WimW. Vanroose. A complementary note on soft errors in the Conjugate Gradient method: the persistent error case Inria Bordeaux Sud-Ouest August 2020
  HAL back to text
• 36 reportEmmanuelE. Agullo, SiegfriedS. Cools, EmrullahE. Fatih-Yetkin, LucL. Giraud, NickN. Schenkels and WimW. Vanroose. On soft errors in the Conjugate Gradient method: sensitivity and robust numerical detection -revisedInria Bordeaux Sud-OuestMarch 2020, 43
  HAL
• 37 misc OlivierO. Beaumont, LionelL. Eyraud-Dubois and AlenaA. Shilova. MadPipe: Memory Aware Dynamic Programming Algorithm for Pipelined Model Parallelism November 2020
  HAL back to text
• 38 misc OlivierO. Beaumont, LionelL. Eyraud-Dubois and AlenaA. Shilova. Pipelined Model Parallelism: Complexity Results and Memory Considerations February 2021
  HAL back to text
• 39 report RocíoR. Carratalá-Sáez, MathieuM. Faverge, GrégoireG. Pichon, GuillaumeG. Sylvand and Enrique SE. Quintana-Ortí. Tiled Algorithms for Efficient Task-Parallel H-Matrix Solvers Inria February 2020
  HAL
• 40 misc LionelL. Eyraud-Dubois and CristianaC. Bentes. Independent tasks on 2 resources with co-scheduling effects January 2020
  HAL back to text
• 41 reportLucL. Giraud, Yan-FeiY.-F. Jing and YanfeiY. Xiang. A block minimum residual norm subspace solver for sequences of multiple left and right-hand side linear systemsInria Bordeaux Sud-OuestFebruary 2021, 52
  HAL
• 42 reportChangjiangC. Gou, AliA. Al Zoobi, AnneA. Benoit, MathieuM. Faverge, LorisL. Marchal, GrégoireG. Pichon and PierreP. Ramet. Improving mapping for sparse direct solvers: A trade-off between data locality and load balancingInria Rhône-AlpesFebruary 2020, 21
  HAL
• 43 report NicolasN. Venkovic, PaulP. Mycek, LucL. Giraud and OlivierO. Le Maitre. Comparative study of harmonic and Rayleigh-Ritz procedures with applications to deflated conjugate gradients Cerfacs January 2020
  HAL

Softwares

• 44 software S. Archipoff, C. Augonnet, O. Aumage, G. Beauchamp, B. Bramas, A. Buttari, A. Cassagne, J. Clet-Ortega, T. Cojean, N. Collin, V. Danjean, A. Denis, L. Eyraud-Dubois, N. Furmento, S. Henry, A. Hugo, M. Juhoor, A. Juven, M. Keryell-Even, Y. Khorsi, T. Lambert, E. Leria, B. Lizé, M. Makni, S. Nakov, R. Namyst, L. Nesi Lucas, P. Joris, D. Pasqualinotto, S. Pitoiset, Q.-D. Nguyen, C. Roelandt, C. Sakka, C. Salingue, L. Mello Schnorr, M. Sergent, A. Simonet, L. Stanisic, B. Subervie, F. Tessier, S. Thibault, B. Videau, L. Villeveygoux and P.-A. Wacrenier. StarPU 1.3.3 hello January 2020
  HAL Softwage Heritage