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.

In an effort to raise awareness on the increasing carbon emissions of Cloud computing, the European Corporate Sustainability Reporting Directive effectively requires providers to supply their customers with an assessment of the carbon impact associated with their use. This represents a challenge for bare metal servers, where the deployment of dedicated power meters is often unfeasible at scale. To address this, we present PPEM-BM, a novel sensor-driven modeling approach to estimate the power consumption of bare metal servers using CPU temperature data acquired via IPMI. PPEM-BM enhances and generalizes the existing PowerHeat method, which correlates CPU temperature with power. Our methodology involves training individual power models, performing cross-evaluation to determine their portability, and then using a Learning to Rank (LTR) model to select the most appropriate pre-trained model for a target server based on its hardware configuration and CPU temperature statistics. An experiment conducted on$\mathbf{1, 0 7 6}$production servers at OVHcloud shows that PPEM-BM demonstrates a significant improvement compared to models based solely on hardware profiles. The approach offers a practical, scalable, and cost-effective solution for hosting providers to monitor energy consumption without widespread sensor deployment.

Information and Communication Technologies (ICT) and Data Centres (DC) have nowadays considerable environmental impacts. The number of applications and services hosted in the cloud is significant, and the associated number of infrastructure is steadily increasing. Cloud Service Providers (CSP) need to respond to this growing demand and size their infrastructures accordingly but users misbehaviour and expectations in terms of service quality lead to oversized infrastructures. Infrastructures are sized to meet peak-demand, resulting in poor resource utilization and additional power consumption. But as their behaviour can increase DC energy consumption and environmental footprint, users can also help reducing them. In this paper, we study how users provided with a simple tool can reduce the power consumption of a virtualization cluster in a cloud company. Using a Virtual Machine (VM) shutdown policy, users can directly contribute to the mitigation of the power consumption of the infrastructure. Part of the paper is dedicated to profile the users and understand their behaviour when it comes to powering off their VMs. To further reduce the energy consumption of the cluster, we combine the VM shutdown policy with a simple consolidation heuristic. Simulations show a 23.95% power consumption reduction, with an additional 8.72% reduction thanks to the users. A production implementation was conducted and results in a 12.58% power consumption reduction over one week.

Best Poster Award.

International audience

In this paper we introduce FicWebBoard, a learning concept and accompanying online platform that allows teaching programming languages to highly heterogeneous groups of students. Students are given great freedom, in particular in their choice of programming languages, but not at the cost of the quality of supervision as they are still under a certain hidden control. Gamification and the opportunity to participate to a challenge (an optional competition), also help to make the concept attractive to students. This original approach targets students with basic knowledge about programming, and allows them to earn deeper or wider programming knowledge. To validate the approach, we designed a survey to collect feedback from past students after using this approach for seven years.

This paper compares the cooling-efficiency between air and immersion cooling methods through the implementation of an experimental framework. Short and long term stresses with and without overclocking were run and monitored on 8 identical HPC servers. A statistical analysis using the Mann-Whitney method was conducted to determine whether or not, the temperature differences observed between the servers cooled by immersion and the ones cooled by air were significant. The results were promising with immersion cooling achieving better overall cooling performance with low energy consumption as no cooling units were used for the immersion cooling system. A discussion on practical issues encountered using the immersion technology is also included.

Deep Learning has shifted the focus of traditional batch workflows to data-driven feature engineering on streaming data. In particular, the execution of Deep Learning workflows presents expectations of near-real-time results with user-defined acceptable accuracy. Meeting the objectives of such applications across heterogeneous resources located at the edge of the network, the core, and in-between requires managing trade-offs between the accuracy and the urgency of the results. However, current data analysis rarely manages the entire Deep Learning pipeline along the data path, making it complex for developers to implement strategies in realworld deployments. Driven by an object detection use case, this paper presents an architecture for time-critical Deep Learning workflows by providing a data-driven scheduling approach to distribute the pipeline across Edge to Cloud resources. Furthermore, it adopts a data management strategy that reduces the resolution of incoming data when potential trade-off optimizations are available. We illustrate the system's viability through a performance evaluation of the object detection use case on the Grid'5000 testbed. We demonstrate that in a multi-user scenario, with a standard frame rate of 25 frames per second, the system speed-up data analysis up to 54.4% compared to a Cloud-only-based scenario with an analysis accuracy higher than a fixed threshold.

Summary This paper introduces several budget‐aware algorithms to deploy scientific workflows on Infrastructure as a Service Cloud platforms, where users can request Virtual Machines (VMs) of different types, each with specific cost and computing resources. We use a realistic application/platform model with stochastic task weights, and VMs communicating through a Cloud storage. We extend two well‐known algorithms, MinMin and HEFT, and make scheduling decisions based upon machine availability and remaining budget. During the mapping process, the budget‐aware algorithms make conservative assumptions to avoid exceeding the initial budget; we further improve the results with refined versions that aim at rescheduling some tasks onto faster VMs, thereby spending any budget fraction leftover by the first allocation. These refined variants are much more time‐consuming than the former algorithms, so there is a trade‐off to find in terms of scalability. We report an extensive set of simulations with workflows from the Pegasus benchmark suite. Most of the time, our budget‐aware algorithms succeed in achieving efficient makespans while enforcing the given budget, and this despite the uncertainty in task weights.

Microservices promise the benefits of services with an efficient granularity using dynamically allocated resources. In the current evolving architectures, data producers and consumers are created as decoupled components that support different data objects and quality of service. Actual implementations of service meshes lack support for data-driven paradigms, and focus on goal-based approaches designed to fulfill the general system goal. This diversity of available components demands the integration of users requirements and data products into the discovery mechanism. This paper proposes a data-driven service discovery framework based on profile matching using data-centric service descriptions. We have designed and evaluated a microservices architecture for providing service meshes with a standalone set of components that manages data profiles and resources allocations over multiple geographical zones. Moreover, we demonstrated an adaptation scheme to provide quality of service guarantees. Evaluation of the implementation on a real life testbed shows effectiveness of this approach with stable and fluctuating request incoming rates.

The Internet of Things has enabled many application scenarios where a large number of connected devices generate unbounded streams of data, often processed by data stream processing frameworks deployed in the cloud. Edge computing enables offloading processing from the cloud and placing it close to where the data is generated, thereby reducing the time to process data events and deployment costs. However, edge resources are more computationally constrained than their cloud counterparts, raising two interrelated issues, namely deciding on the parallelism of processing tasks (a.k.a. operators) and their mapping onto available resources. In this work, we formulate the scenario of operator placement and parallelism as an optimal mixed-integer linear programming problem. The proposed model is termed as Cloud-Edge data Stream Placement (CESP). Experimental results using discrete-event simulation demonstrate that CESP can achieve an end-to-end latency at least ≃ 80% and monetary costs at least ≃ 30% better than traditional cloud deployment.

International audience

Today, the use of software is regulated by licenses, whether they are free, paid for and with or without access to its sources. The number of licenses required for specific software can be calculated with several metrics, each defined by the software vendor. This article will present the impact and importance of managing those licenses when using software in a clouded architecture. We will therefore propose a study of one software sold by Oracle: the Oracle database. We will first review the existing situation and the current problem, then we will propose a deployment algorithm that takes into account two specific metrics for this software. Finally, we will compare our results with various existing deployment algorithms.

Combining computation and water warming is an efficient alternative for recycling dissipated energy. Based on a set of Computing Water Heaters, used as a distributed super computer, we introduce a computing water heater scheduling system that has been validated by simulation on extreme workloads. These simulations lead us to reach an approximate CPU usage of about 60% while minimizing the thermal resistance usage to 10% (only when necessary) on a complex steady state.

International audience

Summary The adoption of cloud computing is still limited by several legal concerns that customers may have, such as data sovereignty. In cloud computing, data can be physically hosted in sensible locations, resulting in a lack of control for companies. In this context, we present the Nu@ge project, which aims at building a federation of container‐sized datacenters in the French territory. Nu@ge provides a software stack that enables companies to interconnect independent datacenters in a national mesh. A software architecture is presented and implemented as a federation of small datacenters deployed in France. The proposed architecture enables cooperation between local customized‐cloud managers and a federation‐wide middleware. It uses monitoring information from facilities and performance indicators from physical servers for managing the system, preventing incidents and considering energy efficiency. Additionally, a prototype of a container‐sized datacenter has been validated and patented.

The recent rapid expansion of Cloud computing facilities triggers an attendant challenge to facility providers and users for methods for optimal placement of workflows on distributed resources, under the often-contradictory impulses of minimizing makespan, energy consumption, and other metrics. Evolutionary Optimization techniques that from theoretical principles are guaranteed to provide globally optimum solutions, are among the most powerful tools to achieve such optimal placements. Multi-Objective Evolutionary algorithms by design work upon contradictory objectives, gradually evolving across generations towards a converged Pareto front representing optimal decision variables — in this case the mapping of tasks to resources on clusters. However the computation time taken by such algorithms for convergence makes them prohibitive for real time placements because of the adverse impact on makespan. This work describes parallelization, on the same cluster, of a Multi-Objective Differential Evolution method (NSDE-II) for optimization of workflow placement, and the attendant speedups that bring the implicit accuracy of the method into the realm of practical utility. Experimental validation is performed on a reallife testbed using diverse Cloud traces. The solutions under different scheduling policies demonstrate significant reduction in energy consumption with some improvement in makespan.

One of the major concerns when moving to Clouds is data confidentiality. Nevertheless, more and more applications are outsourced to a public or private Cloud. In general, the usage of virtualization is acknowledged as an isolation mechanism between applications running on shared resources. But, as previously shown, virtualization does not ensure data security. Indeed, the isolation can be broken due to covert channels existing in both the software and the hardware (e.g., Improperly virtualized caches). Furthermore, even if a perfect control mechanism could be design, it would not protect against covert channels as they bypass control mechanism using legal means. In this paper, we first describe how these attacks are working. Next, after presenting the existing mitigation mechanisms, we show that a good solution is to take into account security while allocating resources (i.e., When placing the VMs). Furthermore, depending on which resources are shared, we demonstrate that the achievable bit rate of these attacks can change dramatically. We propose a new metric to quantify them and use it as an acceptable risk for isolation properties. Then, we show how to use them when allocating resources and the importance of a fine-grained resource allocation mechanism. Finally, we demonstrate that a security-oblivious placement algorithm breaks a fair amount of properties but taking into account the isolation impacts the acceptance rate (i.e., The percentage of successfully placed VMs).

Nowadays, virtualization is used as the sole mechanism to isolate different users on Cloud platforms. In this paper, we show that, due to improper virtualization of micro-architectural components, data leak and modification can occur on public Clouds. Furthermore, using the same vector, it is possible to induce performance interferences, i.e. noisy neighbors. Using this approach, a VM can steal resources from, and slow down, concurrent VMs. To counter this, we propose placement heuristics that take into account isolation requirements, thus allowing a user to specify the level of isolation he accepts, and with whom. We modify 3 classical heuristics to take into account these requirements. In addition, we propose 4 new heuristics that take into account the hierarchy of Cloud platforms and isolation requirements. Finally, we evaluate these heuristics and compare them with the modified classical ones. We show that our heuristics perform at least as well as the classical ones, while scaling better and being faster by a few orders of magnitude.

Software systems are increasingly expected to be self-adaptive. Such software systems have the capability to autonomously modify their behaviour at run-time in response to changes in their environment. This capability may be included in the software systems at design time or later by external mechanisms. Therefore, along their development process multiple adaptation concerns must be considered, such as the response to changes in the utilization patterns, the need for alternative algorithms for implementing a function, or the diversity of the infrastructure. This paper describes an architecture which aims to add self-adaptive capabilities to an existing middleware so that its deployment becomes self-adaptive. The framework uses external mechanisms for that purpose since this capability was not a native feature. The paper describes also a way to model system architecture, a hierarchical middleware architecture and a middleware deployment topology.

To be able to efficiently schedule network transfers on computing platforms such as clusters, grids or clouds, accurate and timely predictions of network transfers completion times are needed. We designed a new metrology and performance prediction framework called Pilgrim which offers a service predicting the completion times of current and concurrent TCP transfers. We describe Pilgrim and show some experimental results comparing the predictions to the real transfer completion times.

Accessing the power of distributed resources can nowadays easily be done using a middleware based on a client/server approach. Several architectures exist for those middleware's. The most scalable ones rely on a hierarchical design. Determining the best shape for the hierarchy, the one giving the best throughput of services, is not an easy task. We first propose a computation and communication model for such hierarchical middleware. Our model takes into account the deployment of several services in the hierarchy. Then, based on this model, we propose algorithms for automatically constructing a hierarchy on two kinds of heterogeneous platforms: communication homogeneous/computation heterogeneous platforms, and fully heterogeneous platforms. The proposed algorithms aim at offering the users the best obtained to requested throughput ratio, while providing fairness on this ratio for the different kinds of services, and using as few resources as possible for the hierarchy. For each kind of platforms, we compare our model with experimental results on a real middleware called DIET (Distributed Interactive Engineering Toolbox).

Spades aims at offering a solution to deal with distributed, volatile and heterogeneous computing resources. The targeted platform is a large one with potentially huge number of resources. In a seamless way, our proposal includes i) an abstraction of the resources in a computing overlay; ii) a P2P distributed resource/service discovery; iii) an user job scheduling workflow; iv) an auto-stabilizing solution and v) optimized algorithms for Petascale architecture. In order to orchestrate Spades platform, we have designed and implemented Sbam middleware.

The Cloud phenomenon brings along the cost-saving benefit of dynamic scaling. As a result, the question of efficient resource scaling arises. Prediction is necessary as the virtual resources that Cloud computing uses have a setup time that is not negligible. We propose an approach to the problem of workload prediction based on identifying similar past occurrences of the current short-term workload history. We present in detail the Cloud client resource auto-scaling algorithm that uses the above approach to help when scaling decisions are made, as well as experimental results by using real-world traces from Cloud and Grid platforms. We also present an overall evaluation of this approach, its potential and usefulness for enabling efficient auto-scaling of Cloud user resources.

It is nowadays common to use a grid middleware to access distributed resources in order to solve large problems. Many middleware can be found in the literature. Whereas they all rely on the use of resource brokers (also sometimes called agents) to schedule jobs, and servers to execute them, they do not share the same structure. Many rely on a simple design, e.g., a star graph (one agent managing several servers); and the most scalable ones rely on a hierarchy of agents. To the best of our knowledge, very few studies have been conducted on the modelization and performance prediction of such middleware. In this paper, we present a model for hierarchical middleware, i.e., based on a tree structure. Then, we compare our model predictions with real executions on the DIET middleware, and provide a few hints on how to attain the best performance.

The cloud phenomenon is quickly growing towards becoming the de facto standard of Internet computing, storage and hosting both in industry and academia. The large scalability possibilities offered by cloud platforms can be harnessed not only for services and applications hosting but also as a raw on-demand computing resource. This paper proposes the use of a cloud system as a raw computational on-demand resource for a grid middleware. We illustrate a proof of concept by considering the DIET-solve grid middleware and the EUCALYPTUS open-source cloud platform.

This paper presents a new data manager that we developed for the DIET middleware: DAGDA. We present new data management features introduced by DAGDA and show the improvements DIET users can obtain by using them. Our experiments results show the validity of the DAGDA data management approach and show how the data management choices can improve the distributed applications performances.

In this paper, we tackle the problem of scheduling an Ocean-Atmosphere application used for climate prediction on the grid. An experiment is composed of several 1D-meshes of identical DAGs composed of parallel tasks. To obtain a good completion time, we divide groups of processors into sets each working on parallel tasks. The group sizes are chosen by computing the best makespan for several grouping possibilities. We improved this heuristic method by different means. The improvement yielding to the best makespan is the representation of the problem as an instance of the Knapsack problem. As this heuristic is firstly designed for homogeneous platforms, we present its adaptation to heterogeneous platforms. Simulations show improvements of the makespan up to 12\%.

The efficiency of service discovery is a crucial point in the development of fully decentralized middlewares intended to manage large scale computational grids. The work conducted on this issue led to the design of many peer- to-peer fashioned approaches. More specifically, the need for flexibility and complexity in the service discovery has seen the emergence of a new kind of overlays, based on tries, also known as lexicographic trees. Although these overlays are efficient and well designed, they require a costly maintenance and do not accurately take into account the heterogeneity of nodes and the changing popularity of the services requested by users. In this paper, we focus on reducing the cost of the maintenance of a particular architecture, based on a dynamic prefix tree, while enhancing it with some load balancing techniques that dynamically adapt the load of the nodes in order to maximize the throughput of the system. The algorithms developed couple a self-organizing prefix tree overlay with load balancing techniques inspired by similar previous works undertaken for distributed hash tables. After some simulation results showing how our load balancing heuristics perform in such an overlay and compare to other heuristics, we provide a fair comparison of this architecture and similar overlays recently proposed.

The use of many distributed, heterogeneous resources as a large collective platform offers great potential. A key issue for these grid platforms is middleware scalability and how middleware services can be mapped on the available resources. Optimizing deployment is a difficult problem with no existing general solutions. In this paper, we address the following problem: how to perform out an adapted deployment for a hierarchy of servers and resource brokers on a heterogeneous system? Our objective is to generate a best platform from the available nodes so as to fulfill the clients demands. However, finding the best deployment among heterogeneous resources is a hard problem since it is close to find the best broadcast tree in a general graph, which is known to be NP-complete. Thus, in this paper, we present a heuristic for middleware deployment on heterogeneous resources. We apply our heuristic to automatically deploy a distributed problem solving environment on a large scale grid. We present experiments comparing the automatically generated deployment against a number of other reasonable deployments.

In this paper, we tackle the problem of scheduling tasks of an Ocean-Atmosphere application used for climate prediction over the Grid. We have designed scheduling solutions for both homogeneous and heterogeneous platforms which have been tested in real experiments on Grid'5000. Additionally we compare our simulations with real experiments to see how accurate our simulations are.

SystemC has become a very popular standardized language for the modeling of System-On-Chip (SoC) devices. However, due to the ever increasing complexity of SoC designs, the ever longer simulation times affect SoC exploration potential and time-to-market. In order to reduce these times, we have developed a parallel SystemC kernel. Because the SystemC semantics require a high level of synchronization which can dramatically affect the performance gains, we investigate in this paper some ways to reduce the synchronization overheads. We validate then our approaches against an academic design model and a real, industrial application.

The efficiency of service discovery is critical in the development of fully decentralized middleware intended to manage large scale computational grids. This demand influenced the design of many peer-to-peer based approaches. The ability to cope with the expressiveness of the service discovery was behind the design of a new kind of overlay structures that is based on tries, or prefix trees. Although these overlays are well designed, one of their weaknesses is the lack of any concrete fault tolerant mechanism, especially in dynamic platforms; the faults are handled by using preventive and costly mechanisms, \eg using a high degree of replication. Moreover, those systems cannot handle any arbitrary transient failure. Self-stabilization, which is an efficient approach to designreliable solutions for dynamic systems, was recently suggested to be a good alternative to inject fault-tolerance in peer-to-peer systems. However, most of the previous research on self-stabilization in tree and/or P2P networks was designed in theoretical models, making these approaches hard to implement in practice. In this paper, we provide a self-stabilizing message passing protocol to maintain prefix trees over practical peer-to-peer networks. A complete correctness proof is provided, as well as simulation results to estimate the practical impact of our protocol.

Abstract Among existing grid middleware approaches, one simple, powerful, and flexible approach consists of using servers available in different administrative domains through the classic client–server or remote procedure call paradigm. Network Enabled Servers (NES) implement this model, also called GridRPC. Clients submit computation requests to a scheduler, whose goal is to find a server available on the grid using some performance metric. The aim of this paper is to give an overview of a NES middleware developed in the GRAAL team called distributed interactive engineering toolbox (DIET) and to describe recent developments around plug‐in schedulers, workflow management, and tools. DIET is a hierarchical set of components used for the development of applications based on computational servers on the grid. Copyright © 2007 John Wiley & Sons, Ltd.

Large problems ranging from numerical simulation can now be solved through the Internet using grid middleware. This paper describes the different steps involved to make available a service in the DIET grid middleware. The cosmological RAMSES application is taken as an example to detail the implementation. Furthermore, several results are given in order to show the benefits of using DIET, among which the transparent usage of numerous clusters and a low overhead (finding the right resource and submitting the computing task).

In this paper we study how distributed scheduling systems can be designed most effectively; we focus on the problem of selecting an optimal arrangement of schedulers, or a deployment, for hierarchically organized systems. We show that the optimal deployment is a complete spanning d-ary tree; this result conforms with results from the scheduling literature. More importantly, we present an approach for determining the optimal degree d for the tree. We test our approach using DIET, a network-enabled server system that uses hierarchical schedulers. Finally, we demonstrate that our approach selects deployments that are near-optimal in practice

Within computational grids, some services (software components, linear algebra libraries, etc.) are made available by some servers to some clients. In spite of the growing popularity of such grids, the service discovery, although efficient in many cases, does not reach several requirements. Among them, the flexibility of the discovery and its efficiency on wide-area dynamic platforms are two major issues. Therefore, it becomes crucial to propose new tools coping with such platforms. Emerging peer-to-peer technologies provide algorithms allowing the distribution and the retrieval of data items while addressing the dynamicity of the underlying network. We study in this paper the service discovery in a pure peer-to-peer environment. We describe a new trie-based approach for the service discovery that supports range queries and automatic completion of partial search strings, while providing fault-tolerance, and partially taking into account the topology of the underlying network. We validate this approach both by analysis and simulation. Traditional metrics considered in peer-to-peer systems exhibits interesting complexities within our architecture. The analysis' results are confirmed by some simulation experiments run using several grid's data sets

DIET (Distributed Interactive Engineering Toolbox) is a set of hierarchical components to design network enabled server (NES) systems. In these systems, clients ask to agents (discovery and scheduling components) to find servers able to solve their problem using some performance metrics and information about the location of data already on the network. Today's NES middleware, in which agents are statically connected and potentially bottlenecks, don't cope with the dynamic and heterogeneous nature of future grid environments. In this paper, we present the design, the implementation and the experimentation of the first architecture extending traditional NES systems with an unstructured peer-to-peer network dynamically connecting distributed agents, to provide to clients an entry point to servers geographically distributed. Our implementation is based on DIET and the JXTA toolbox. Different algorithms have been implemented and experimented over the VTHD network which connects several supercomputers in different research institutes through a high-speed network, showing the scalability of the system

In this paper we present a model and simulator for many clusters of heterogeneous PCs belonging to a local network. These clusters are assumed to be connected to each other through a global network and each cluster is managed via a local scheduler which is shared by many users. We validate our simulator by comparing the experimental and analytical results of a M/M/4 queuing system. These studies indicate that the simulator is consistent. Next, we do the comparison with a real batch system and we obtain an average error of 10.5% for the response time and 12% for the makespan. We conclude that the simulator is realistic and well as the behaviour of a large-scale system. Thus we can study the scheduling of our system called DIRAC in a high throughput context. We justify our decentralized, adaptive and opportunistic approach in comparison to a centralized approach in such a context

Summary form only given. This article focuses on the deployment of grid infrastructures, more specifically problem solving environments (PSE) for numerical applications on the grid. Although the deployment of such an architecture may be constrained e.g., firewall, right access or security, its efficiency heavily depends on the quality of the mapping between its different components and the grid resources. This article proposes a new model based on linear programming to estimate the performance of a deployment of a hierarchical PSE. The advantages of our modeling approach are: evaluate a virtual deployment before a real deployment, provide a decision builder tool (i.e., designed to compare different architectures or add new resources) and take into account the platform scalability. Using our model, it is possible to determine the bottleneck of the platform and thus to know whether a given deployment can be improved or not. We illustrate the model by applying the results to improve performance of an existing hierarchical PSE called DIET.