As the demand for AI-driven workloads increases, the energy consumption of Graphics Processing Units (GPUs) devices has come under intense scrutiny, particularly in hyperscale data centers where large numbers of accelerators are centralized and leased to diverse clients.

International audience

Energy consumption has become a critical concern in Information and Communication Technologies (ICT), pressing for more accurate measurements. While the power consumption of physical servers can be physically monitored, organizations are increasingly adopting virtual environments, such as cloud computing, rendering physical measurements impractical in operational contexts. The state-of-the-art approaches to estimating this ”virtual” consumption mostly consist of assigning server power consumption shares among hosted processes, guided by various system metrics. Unfortunately, such a bottom-up approach is highly sensitive in a multi-tenant environment, thus failing to report stable measurements to stakeholders. For example, the same activity performed by one Virtual Machine (VM) may lead to different power consumption traces, depending on the activity of the co-hosted VMs. As cloud customers have only control over their provisioned virtual resources, we propose a new method to model the power consumption of their virtual appliances, enabling contextagnostic tracking of their environmental impact. This framework, called CINERGY, is designed to be more predictable than the state-of-the-art power models, while still exposing the gains from consolidation. We evaluate its accuracy against ground-truth measurements, often lacking in the literature. We show that CINERGY is deterministic and accurate, with an average error of 6.6%.

The topic-based publish-subscribe paradigm plays an important role among many applications, as it enables a seamless interconnection of heterogeneous client applications and devices, through easy-to-use high-level abstractions. While publish-subscribe systems are usually provided in a centralized (i.e., broker-based) model, a peer-to-peer (P2P) topology can bring several benefits, such as increased resiliency and scalability, better load distribution, and a better handling of hot topics that comprise a large amount of publishers and subscribers. The presence of hot topics can result in high outgoing bandwidth usage, which is an important consideration in edge-based deployments.This paper presents MQTT2EdgePeer, a robust and scalable P2P brokerless topic-based publish-subscribe middleware that provides compatibility with MQTT-based applications. MQTT2EdgePeer, which is built on top of a structured edge P2P overlay, provides two message delivery approaches that enable a trade-off between efficient bandwidth distribution among the nodes, and latency minimization. Our findings reveal that MQTT2EdgePeer provides improved scalability, better load distribution, and reduced latencies, in comparison with a state-of-the-art Distributed Single Root per Topic (DSRT) approach.

As exascale platforms are in sight, high-performance computing needs to take failures into account and provide fault-tolerant applications and environments. Checkpoint-restart approaches do not require modifying the application, but are expensive at large scale. Application-based fault tolerance is more specific to the application and is expected to achieve better performance. In this paper, we address fault-tolerant matrix factorization with algorithms that present good performance, both during failure-free executions and when failures happen. A challenge when designing fault-tolerant algorithms is to make sure they are resilient to any failure scenario. Therefore, we design a model for these algorithms and prove they can tolerate failures at any moment, as long as enough processes are still alive.

Summary In this article, we introduce DiPOSH, a multi‐network, distributed implementation of the OpenSHMEM standard. The core idea behind DiPOSH is to have an API‐to‐network software stack as slim as possible, in order to minimize the software overhead. Following the heritage of its non‐distributed parent POSH, DiPOSH's communication engine is organized around the processes' shared heaps, and remote communications are moving data from and to these shared heaps directly. This article presents its architecture and several communication drivers, including one that takes advantage of a helper process, called the Hub, for inter‐process communications. This architecture allows use to explore different options for implementing the communication drivers, from using high‐level, portable, optimized libraries to low‐level, close to the hardware communication routines. We present the perspectives opened by this additional component in terms of communication scheduling between and on the nodes. DiPOSH is available at https://github.com/coti/DiPOSH .

Summary Parametric linear programming is a central operation for polyhedral computations, as well as in certain control applications. Here, we propose a task‐based scheme for parallelizing it, with quasi‐linear speedup over large problems. This type of parallel applications is challenging, because several tasks might be computing the same region. In this article, we are presenting the algorithm itself with a parallel redundancy elimination algorithm, and conducting a thorough performance analysis.

Group invariants are used in high energy physics to define quantum field theory interactions. In this paper, we present the parallel algebraic computation of special invariants called symplectic and focus on one particular invariant that finds recent interest in physics. Our results will export to other invariants. The cost of performing basic computations on the multivariate polynomials evolves during the computation, as the polynomials get larger and/or have increasing numbers of terms. Interestingly, in some cases, they stay small. Traditionally, high-performance software is optimized by running experiments with sample data sets in order to profile and optimize expected behavior of workloads in practice. Since the (communication and computation) costs depend on the changing behavior of the symplectic invariant calculations, the standard optimization approach is insufficient. Thus, it is necessary to implement online performance tuning methods that can track the algorithm's progress and state, evaluate performance data in situ, and control the parallel resources during execution.

A dynamic partial order reduction (DPOR) algorithm is optimal when it always explores at most one representative per Mazurkiewicz trace. Existing literature suggests that the reduction obtained by the non-optimal, state-of-the-art Source-DPOR (SDPOR) algorithm is comparable to optimal DPOR. We show the first program with $$\mathop {\mathcal {O}} (n)$$ Mazurkiewicz traces where SDPOR explores $$\mathop {\mathcal {O}} (2^n)$$ redundant schedules (as this paper was under review, we were made aware of the recent publication of another paper [3] which contains an independently-discovered example program with the same characteristics). We furthermore identify the cause of this blow-up as an NP-hard problem. Our main contribution is a new approach, called Quasi-Optimal POR, that can arbitrarily approximate an optimal exploration using a provided constant k. We present an implementation of our method in a new tool called Dpu using specialised data structures. Experiments with Dpu, including Debian packages, show that optimality is achieved with low values of k, outperforming state-of-the-art tools.

We propose a distributed implementation of the collapse compression technique used by explicit state model checkers to reduce memory usage. This adapatation makes use of lock-free distributed hash tables based on one-sided communication primitives provided by libraries such as OpenSHMEM. We implemented this technique in the distributed version of the model checker Helena. We report on experiments performed on the Grid'5000 cluster with an implementation over OpenMPI. These reveal that, for some models, this distributed implementation can altogether preserve the memory reduction provided by collapse compression and reduce execution times by allowing the exchanges of compressed states between processes.

In this paper we present MLTBiqCrunch, a hierarchically parallelized version of the open-source solver BiqCrunch [1].More precisely, this version has two levels of parallelization: a coarse grain, assigning a thread to a node evaluation and a fine grain, parallelizing a node evaluation when some threads are not busy.We present experiments on some classical binary quadratic optimization problems with comparison of their scalability and raw performance.In particular, we obtain a superlinear speedup for some of the most difficult instances.

Previous studies have reported that common dense linear algebra operations do not achieve speed up by using multiple geographical sites of a computational grid. Because such operations are the building blocks of most scientific applications, conventional supercomputers are still strongly predominant in high-performance computing and the use of grids for speeding up large-scale scientific problems is limited to applications exhibiting parallelism at a higher level. We have identified two performance bottlenecks in the distributed memory algorithms implemented in ScaLAPACK, a state-of-the-art dense linear algebra library. First, because ScaLA-PACK assumes a homogeneous communication network, the implementations of ScaLAPACK algorithms lack locality in their communication pattern. Second, the number of messages sent in the ScaLAPACK algorithms is significantly greater than other algorithms that trade flops for communication. In this paper, we present a new approach for computing a QR factorization – one of the main dense linear algebra kernels – of tall and skinny matrices in a grid computing environment that overcomes these two bottlenecks. Our contribution is to articulate a recently proposed algorithm (Communication Avoiding QR) with a topology-aware middleware (QCG-OMPI) in order to confine intensive communications (ScaLAPACK calls) within the different geographical sites. An experimental study conducted on the Grid'5000 platform shows that the resulting performance increases linearly with the number of geographical sites on large-scale problems (and is in particular consistently higher than ScaLAPACK's).

UNLABELLED: Bioinformaticians are tackling increasingly computation-intensive tasks. In the meantime, workstations are shifting towards multi-core architectures and even massively multi-core may be the norm soon. Bag-of-Tasks (BoT) applications are commonly encountered in bioinformatics. They consist of a large number of independent computation-intensive tasks. This note introduces PAR, a scalable, dynamic, parallel and distributed execution engine for Bag-of-Tasks. PAR is aimed at multi-core architectures and small clusters. Accelerations obtained thanks to PAR on two different applications are shown. AVAILABILITY: PAR is released under the GNU General Public License version three and can be freely downloaded (http://download.savannah.gnu.org/releases/par/par.tgz).

The concept of topology-aware grid applications is derived from parallelized computational models of complex systems that are executed on heterogeneous resources, either because they require specialized hardware for certain calculations, or because their parallelization is flexible enough to exploit such resources. Here we describe two such applications, a multi-body simulation of stellar evolution, and an evolutionary algorithm that is used for reverse-engineering gene regulatory networks. We then describe the topology-aware middleware we have developed to facilitate the "modeling-implementing-executing" cycle of complex systems applications. The developed middleware allows topology-aware simulations to run on geographically distributed clusters with or without firewalls between them. Additionally, we describe advanced coallocation and scheduling techniques that take into account the applications topologies. Results are given based on running the topology-aware applications on the Grid'5000 infrastructure.

We investigate how well Gaussian process regression can learn functions defined on graphs, using large regular random graphs as a paradigmatic example. Random-walk based kernels are shown to have some surprising properties: within the standard approximation of a locally tree-like graph structure, the kernel does not become constant, i.e.neighbouring function values do not become fully correlated, when the lengthscale $\sigma$ of the kernel is made large. Instead the kernel attains a non-trivial limiting form, which we calculate. The fully correlated limit is reached only once loops become relevant, and we estimate where the crossover to this regime occurs. Our main subject are learning curves of Bayes error versus training set size. We show that these are qualitatively well predicted by a simple approximation using only the spectrum of a large tree as input, and generically scale with $n/V$, the number of training examples per vertex. We also explore how this behaviour changes once kernel lengthscales are large enough for loops to become important.

Institutional grids consist of the aggregation of clusters belonging to different administrative domains to build a single parallel machine. To run an MPI application over an institutional grid, one has to address many challenges. One of the first problems to solve is the connectivity of the different nodes not belonging to the same administrative domain. Techniques based on communication relays, dynamic port opening, among others, have been proposed. In this work, we propose a set of Grid or Web Services to abstract this connectivity service, and we evaluate the performances of this new level of communication for establishing the connectivity of an MPI application over an experimental grid.

A long-term trend in high-performance computing is the increasing number of nodes in parallel computing platforms, which entails a higher failure probability. Fault tolerant programming environments should be used to guarantee the safe execution of critical applications. Research in fault tolerant MPI has led to the development of several fault tolerant MPI environments. Different approaches are being proposed using a variety of fault tolerant message passing protocols based on coordinated checkpointing or message logging. The most popular approach is with coordinated checkpointing. In the literature, two different concepts of coordinated checkpointing have been proposed: blocking and nonblocking. However they have never been compared quantitatively and their respective scalability remains unknown. The contribution of this paper is to provide the first comparison between these two approaches and a study of their scalability. We have implemented the two approaches within the MPICH environments and evaluate their performance using the NAS parallel benchmarks.