2023Activity reportProject-TeamDATAMOVE

4.1.1 Algorithms

The most common batch scheduling policy is to consider the jobs according to the First Come First Served order (FCFS) with backfilling (BF). BF is the most widely used policy due to its easy and robust implementation and known benefits such as high system utilization. It is well-known that this strategy does not optimize any sophisticated function, but it is simple to implement and it guarantees that there is no starvation (i.e. every job will be scheduled at some moment).

More advanced algorithms are seldom used on production platforms due to both the gap between theoretical models and practical systems and speed constraints. When looking at theoretical scheduling problems, the generally accepted goal is to provide polynomial algorithms (in the number of submitted jobs and the number of involved computing units). However, with millions of processing cores where every process and data transfer have to be individually scheduled, polynomial algorithms are prohibitive as soon as the polynomial degree is too large. The model of parallel tasks simplifies this problem by bundling many threads and communications into single boxes, either rigid, rectangular or malleable. Especially malleable tasks capture the dynamicity of the execution. Yet these models are ill-adapted to heterogeneous platforms, as the running time depends on more than simply the number of allotted resources, and some of the common underlying assumptions on the speed-up functions (such as monotony or concavity) are most often only partially verified.

In practice, the job execution times depend on their allocation (due to communication interferences and heterogeneity in both computation and communication), while theoretical models of parallel jobs usually consider jobs as black boxes with a fixed (maximum) execution time. Though interesting and powerful, the classical models (namely, synchronous PRAM model, delay, LogP) and their variants (such as hierarchical delay), are not well-suited to large scale parallelism on platforms where the cost of moving data is significant, non uniform and may change over time. Recent studies are still refining such models in order to take into account communication contentions more accurately while remaining tractable enough to provide a useful tool for algorithm design.

Today, all algorithms in use in production systems are oblivious to communications. One of our main goals is to design a new generation of scheduling algorithms fitting more closely job schedules according to platform topologies.

4.1.2 Locality Aware Allocations

Recently, we developed modifications of the standard back-filling algorithm taking into account platform topologies. The proposed algorithms take into account locality and contiguity in order to hide communication patterns within parallel tasks. The main result here is to establish good lower bounds and small approximation ratios for policies respecting the locality constraints. The algorithms work in an online fashion, improving the global behavior of the system while still keeping a low running time. These improvements rely mainly on our past experience in designing approximation algorithms. Instead of relying on complex networking models and communication patterns for estimating execution times, the communications are disconnected from the execution time. Then, the scheduling problem leads to a trade-off: optimizing locality of communications on one side and a performance objective (like the makespan or stretch) on the other side.

In the perspective of taking care of locality, other ongoing works include the study of schedulers for platforms whose interconnection network is a static structured topology (like the 3D-torus of the BlueWaters platform we work on in collaboration with the Argonne National Laboratory). One main characteristic of this 3D-torus platform is to provide I/O nodes at specific locations in the topology. Applications generate and access specific data and are thus bounded to specific I/O nodes. Resource allocations are constrained in a strong and unusual way. This problem is close for actual hierarchical platforms. The scheduler needs to compute a schedule such that I/O nodes requirements are filled for each application while at the same time avoiding communication interferences. Moreover, extra constraints can arise for applications requiring accelerators that are gathered on the nodes at the edge of the network topology.

While current results are encouraging, they are however limited in performance by the low amount of information available to the scheduler. We look forward to extend ongoing work by progressively increasing application and network knowledge (by technical mechanisms like profiling or monitoring or by more sophisticated methods like learning). It is also important to anticipate on application resource usage in terms of compute units, memory as well as network and I/Os to efficiently schedule a mix of applications with different profiles. For instance, a simple solution is to partition the jobs as "communication intensive" or "low communications". Such a tag could be achieved by the users them selves or obtained by learning techniques. We could then schedule low communications jobs using leftover spaces while taking care of high communication jobs. More sophisticated options are possible, for instance those that use more detailed communication patterns and networking models. Such options would leverage the work proposed in Section 4.2 for gathering application traces.

4.1.3 Data-Centric Processing

Exascale computing is shifting away from the traditional compute-centric models to a more data-centric one. This is driven by the evolving nature of large scale distributed computing, no longer dominated by pure computations but also by the need to handle and analyze large volumes of data. These data can be large databases of results, data streamed from a running application or another scientific instrument (collider for instance). These new workloads call for specific resource allocation strategies.

Data movements and storage are expected to be a major energy and performance bottleneck on next generation platforms. Storage architectures are also evolving, the standard centralized parallel file system being complemented with local persistent storage (Burst Buffers, NVRAM). Thus, one data producer can stage data on some nodes' local storage, requiring to schedule close by the associated analytics tasks to limit data movements. This kind of configuration, often referred as in-situ analytics, is expected to become common as it enables to switch from the traditional I/O intensive workflow (batch-processing followed by post mortem analysis and visualization) to a more storage conscious approach where data are processed as closely as possible to where and when they are produced (in-situ processing is addressed in details in section 4.3). By reducing data movements and scheduling the extra processing on resources not fully exploited yet, in-situ processing is expected to have also a significant positive energetic impact. Analytics codes can be executed in the same nodes than the application, often on dedicated cores commonly called helper cores, or on dedicated nodes called stagging nodes. The results are either forwarded to the users for visualization or saved to disk through I/O nodes. In-situ analytics can also take benefit of node local disks or burst buffers to reduce data movements. Future job scheduling strategies should take into account in-situ processes in addition to the job allocation to optimize both energy consumption and execution time. On the one hand, this problem can be reduced to an allocation problem of extra asynchronous tasks to idle computing units. But on the other hand, embedding analytics in applications brings extra difficulties by making the application more heterogeneous and imposing more constraints (data affinity) on the required resources. Thus, the main point here is to develop efficient algorithms for dealing with heterogeneity without increasing the global computational cost.

4.1.4 Learning

Another important issue is to adapt the job management system to deal with the bad effects of uncertainties, which may be catastrophic in large scale heterogeneous HPC platforms (jobs delayed arbitrarly far or jobs killed). A natural question is then: is it possible to have a good estimation of the job and platform parameters in order to be able to obtain a better scheduling ? Many important parameters (like the number or type of required resources or the estimated running time of the jobs) are asked to the users when they submit their jobs. However, some of these values are not accurate and in many cases, they are not even provided by the end-users. In DataMove, we propose to study new methods for a better prediction of the characteristics of the jobs and their execution in order to improve the optimization process. In particular, the methods well-studied in the field of big data (in supervised Machine Learning, like classical regression methods, Support Vector Methods, random forests, learning to rank techniques or deep learning) could and must be used to improve job scheduling in large scale HPC platforms. This topic received a great attention recently in the field of parallel and distributed processing. A preliminary study has been done recently by our team with the target of predicting the job running times (called wall times). We succeeded to improve significantly in average the reference EASY Back Filling algorithm by estimating the wall time of the jobs, however, this method leads to big delay for the stretch of few jobs. Even if we succeed in determining more precisely hidden parameters, like the wall time of the jobs, this is not enough to determine an optimized solution. The shift is not only to learn on dedicated parameters but also on the scheduling policy. The data collected from the accounting and profiling of jobs can be used to better understand the needs of the jobs and through learning to propose adaptations for future submissions. The goal is to propose extensions to further improve the job scheduling and improve the performance and energy efficiency of the application. For instance preference learning may enable to compute on-line new priorities to back-fill the ready jobs.

4.1.5 Multi-objective Optimization

Several optimization questions that arise in allocation and scheduling problems lead to the study of several objectives at the same time. The goal is then not a single optimal solution, but a more complicated mathematical object that captures the notion of trade-off. In broader terms, the goal of multi-objective optimization is not to externally arbitrate on disputes between entities with different goals, but rather to explore the possible solutions to highlight the whole range of interesting compromises. A classical tool for studying such multi-objective optimization problems is to use Pareto curves. However, the full description of the Pareto curve can be very hard because of both the number of solutions and the hardness of computing each point. Addressing this problem will opens new methodologies for the analysis of algorithms.

To further illustrate this point here are three possible case studies with emphasis on conflicting interests measured with different objectives. While these cases are good representatives of our HPC context, there are other pertinent trade-offs we may investigate depending on the technology evolution in the coming years. This enumeration is certainly not limitative.

Energy versus Performance. The classical scheduling algorithms designed for the purpose of performance can no longer be used because performance and energy are contradictory objectives to some extent. The scheduling problem with energy becomes a multi-objective problem in nature since the energy consumption should be considered as equally important as performance at exascale. A global constraint on energy could be a first idea for determining trade-offs but the knowledge of the Pareto set (or an approximation of it) is also very useful.

Administrators versus application developers. Both are naturally interested in different objectives: In current algorithms, the performance is mainly computed from the point of view of administrators, but the users should be in the loop since they can give useful information and help to the construction of better schedules. Hence, we face again a multi-objective problem where, as in the above case, the approximation of the Pareto set provides the trade-off between the administrator view and user demands. Moreover, the objectives are usually of the same nature. For example, max stretch and average stretch are two objectives based on the slowdown factor that can interest administrators and users, respectively. In this case the study of the norm of stretch can be also used to describe the trade-off (recall that the $L_1$-norm corresponds to the average objective while the $L_{\infty }$-norm to the max objective). Ideally, we would like to design an algorithm that gives good approximate solutions at the same time for all norms. The $L_2$ or $L_3$-norm are useful since they describe the performance of the whole schedule from the administrator point of view as well as they provide a fairness indication to the users. The hard point here is to derive theoretical analysis for such complicated tools.

Resource Augmentation. The classical resource augmentation models, i.e. speed and machine augmentation, are not sufficient to get good results when the execution of jobs cannot be frequently interrupted. However, based on a resource augmentation model recently introduced, where the algorithm may reject a small number of jobs, some members of our team have given the first interesting results in the non-preemptive direction. In general, resource augmentation can explain the intuitive good behavior of some greedy algorithms while, more interestingly, it can give ideas for new algorithms. For example, in the rejection context we could dedicate a small number of nodes for the usually problematic rejected jobs. Some initial experiments show that this can lead to a schedule for the remaining jobs that is very close to the optimal one.

4.2.1 Workload Traces with Resource Consumption

Workload traces are the base element to capture the behavior of complete systems composed of submitted jobs, running applications, and operating tools. These traces must be obtained on production platforms to provide relevant and representative data. To get a better understanding of the use of such systems, we need to look at both, how the jobs interact with the job management system, and how they use the allocated resources. We propose a general workload trace format that adds jobs resource consumption to the commonly used Standard Workload Format workload trace format. This requires to instrument the platforms, in particular to trace resource consumptions like CPU, data movements at memory, network and I/O levels, with an acceptable performance impact. In a previous work we studied and proposed a dedicated job monitoring tool whose impact on the system has been measured as lightweight (0.35$\%$ speed-down) with a 1 minute sampling rate. Other tools also explore job monitoring, like TACC Stats. A unique feature from our tool is its ability to monitor distinctly jobs sharing common nodes.

Collected workload traces with jobs resource consumption will be publicly released and serve to provide data for works presented in Section 4.1. The trace analysis is expected to give valuable insights to define models encompassing complex behaviours like network topology sensitivity, network congestion and resource interferences.

We expect to join efforts with partners for collecting quality traces (ATOS/Bull, Ciment meso center, Joint Laboratory on Extreme Scale Computing) and will collaborate with the INRIA team POLARIS for their analysis.

4.2.2 Simulation

Simulations of large scale systems are faster by multiple orders of magnitude than real experiments. Unfortunately, replacing experiments with simulations is not as easy as it may sound, as it brings a host of new problems to address in order to ensure that the simulations are closely approximating the execution of typical workloads on real production clusters. Most of these problems are actually not directly related to scheduling algorithms assessment, in the sense that the workload and platform models should be defined independently from the algorithm evaluations, in order to ensure a fair assessment of the algorithms' strengths and weaknesses. These research topics (namely platform modeling, job models and simulator calibration) are addressed in the other subsections.

We developed an open source platform simulator within DataMove (in conjunction with the OAR development team) to provide a widely distributable test bed for reproducible scheduling algorithm evaluation. Our simulator, named Batsim, allows to simulate the behavior of a computational platform executing a workload scheduled by any given scheduling algorithm. To obtain sound simulation results and to broaden the scope of the experiments that can be done thanks to Batsim, we did not chose to create a (necessarily limited) simulator from scratch, but instead to build on top of the SimGrid simulation framework.

To be open to as many batch schedulers as possible, Batsim decouples the platform simulation and the scheduling decisions in two clearly-separated software components communicating through a complete and documented protocol. The Batsim component is in charge of simulating the computational resources behaviour whereas the scheduler component is in charge of taking scheduling decisions. The scheduler component may be both a resource and a job management system. For jobs, scheduling decisions can be to execute a job, to delay its execution or simply to reject it. For resources, other decisions can be taken, for example to change the power state of a machine i.e. to change its speed (in order to lower its energy consumption) or to switch it on or off. This separation of concerns also enables interfacing with potentially any commercial RJMS, as long as the communication protocol with Batsim is implemented. A proof of concept is already available with the OAR RJMS.

Using this test bed opens new research perspectives. It allows to test a large range of platforms and workloads to better understand the real behavior of our algorithms in a production setting. In turn, this opens the possibility to tailor algorithms for a particular platform or application, and to precisely identify the possible shortcomings of the theoretical models used.

4.2.3 Job and Platform Models

The central purpose of the Batsim simulator is to simulate job behaviors on a given target platform under a given resource allocation policy. Depending on the workload, a significant number of jobs are parallel applications with communications and file system accesses. It is not conceivable to simulate individually all these operations for each job on large plaforms with their associated workload due to implied simulation complexity. The challenge is to define a coarse grain job model accurate enough to reproduce parallel application behavior according to the target platform characteristics. We will explore models similar to the BSP (Bulk Synchronous Program) approach that decomposes an application in local computation supersteps ended by global communications and a global synchronization. The model parameters will be established by means of trace analysis as discussed previously, but also by instrumenting some parallel applications to capture communication patterns. This instrumentation will have a significant impact on the concerned application performance, restricting its use to a few applications only. There are a lot of recurrent applications executed on HPC platform, this fact will help to reduce the required number of instrumentations and captures. To assign each job a model, we are considering to adapt the concept of application signatures as proposed in. Platform models and their calibration are also required. Large parts of these models, like those related to network, are provided by Simgrid. Other parts as the filesystem and energy models are comparatively recent and will need to be enhanced or reworked to reflect the HPC platform evolutions. These models are then generally calibrated by running suitable benchmarks.

4.2.4 Emulation and Reproducibility

The use of coarse models in simulation implies to set aside some details. This simplification may hide system behaviors that could impact significantly and negatively the metrics we try to enhance. This issue is particularly relevant when large scale platforms are considered due to the impossibility to run tests at nominal scale on these real platforms. A common approach to circumvent this issue is the use of emulation techniques to reproduce, under certain conditions, the behavior of large platforms on smaller ones. Emulation represents a natural complement to simulation by allowing to execute directly large parts of the actual evaluated software and system, but at the price of larger compute times and a need for more resources. The emulation approach was chosen in to compare two job management systems from workload traces of the CURIE supercomputer (80000 cores). The challenge is to design methods and tools to emulate with sufficient accuracy the platform and the workload (data movement, I/O transfers, communication, applications interference). We will also intend to leverage emulation tools like Distem from the MADYNES team. It is also important to note that the Batsim simulator also uses emulation techniques to support the core scheduling module from actual RJMS. But the integration level is not the same when considering emulation for larger parts of the system (RJMS, compute node, network and filesystem).

Replaying traces implies to prepare and manage complex software stacks including the OS, the resource management system, the distributed filesystem and the applications as well as the tools required to conduct experiments. Preparing these stacks generate specific issues, one of the major one being the support for reproducibility. We propose to further develop the concept of reconstructability to improve experiment reproducibility by capturing the build process of the complete software stack. This approach ensures reproducibility over time better than other ways by keeping all data (original packages, build recipe and Kameleon engine) needed to build the software stack.

In this context, the Grid'5000 (see Sec. 7.2) experimentation infrastructure that gives users the control on the complete software stack is a crucial tool for our research goals. We will pursue our strong implication in this infrastructure.

4.3.1 Programming Model and Software Architecture

In situ creates a tighter loop between the scientist and her/his simulation. As such, an in situ framework needs to be flexible to let the user define and deploy its own set of analysis. A manageable flexibility requires to favor simplicity and understandability, while still enabling an efficient use of parallel resources. Visualization libraries like VTK or Visit, as well as domain specific environments like VMD have initially been developed for traditional post-mortem data analysis. They have been extended to support in situ processing with some simple resource allocation strategies but the level of performance, flexibility and ease of use that is expected requires to rethink new environments. There is a need to develop a middleware and programming environment taking into account in its fundations this specific context of high performance scientific analytics.

Similar needs for new data processing architectures occurred for the emerging area of Big Data Analytics, mainly targeted to web data on cloud-based infrastructures. Google Map/Reduce and its successors like Spark or Stratosphere/Flink have been designed to match the specific context of efficient analytics for large volumes of data produced on the web, on social networks, or generated by business applications. These systems have mainly been developed for cloud infrastructures based on commodity architectures. They do not leverage the specifics of HPC infrastructures. Some preliminary adaptations have been proposed for handling scientific data in a HPC context. However, these approaches do not support in situ processing.

Following the initial development of FlowVR, our middleware for in situ processing, we will pursue our effort to develop a programming environment and software architecture for high performance scientific data analytics. Like FlowVR, the map/reduce tools, as well as the machine learning frameworks like TensorFlow, adopted a dataflow graph for expressing analytics pipe-lines. We are convinced that this dataflow approach is both easy to understand and yet expresses enough concurrency to enable efficient executions. The graph description can be compiled towards lower level representations, a mechanism that is intensively used by Stratosphere/Flink for instance. Existing in situ frameworks, including FlowVR, inherit from the HPC way of programming with a thiner software stack and a programming model close to the machine. Though this approach enables to program high performance applications, this is usually too low level to enable the scientist to write its analysis pipe-line in a short amount of time. The data model, i.e. the data semantics level accessible at the framework level for error check and optimizations, is also a fundamental aspect of such environments. The key/value store has been adopted by all map/reduce tools. Except in some situations, it cannot be adopted as such for scientific data. Results from numerical simulations are often more structured than web data, associated with acceleration data structures to be processed efficiently. We will investigate data models for scientific data building on existing approaches like Adios or DataSpaces.

4.3.2 Resource Sharing

To alleviate the I/O bottleneck, the in situ paradigm proposes to start processing data as soon as made available by the simulation, while still residing in the memory of the compute node. In situ processings include data compression, indexing, computation of various types of descriptors (1D, 2D, images, etc.). Per se, reducing data output to limit I/O related performance drops or keep the output data size manageable is not new. Scientists have relied on solutions as simple as decreasing the frequency of result savings. In situ processing proposes to move one step further, by providing a full fledged processing framework enabling scientists to more easily and thoroughly manage the available I/O budget.

The most direct way to perform in situ analytics is to inline computations directly in the simulation code. In this case, in situ processing is executed in sequence with the simulation that is suspended meanwhile. Though this approach is direct to implement and does not require complex framework environments, it does not enable to overlap analytics related computations and data movements with the simulation execution, preventing to efficiently use the available resources. Instead of relying on this simple time sharing approach, several works propose to rely on space sharing where one or several cores per node, called helper cores, are dedicated to analytics. The simulation responsibility is simply to handle a copy of the relevant data to the node-local in situ processes, both codes being executed concurrently. This approach often lead to significantly beter performance than in-simulation analytics.

For a better isolation of the simulation and in situ processes, one solution consists in offloading in situ tasks from the simulation nodes towards extra dedicated nodes, usually called staging nodes. These computations are said to be performed in-transit. But this approach may not always be beneficial compared to processing on simulation nodes due to the costs of moving the data from the simulation nodes to the staging nodes.

FlowVR enables to mix these different resources allocation strategies for the different stages of an analytics pile-line. Based on a component model, the scientist designs analytics workflows by first developing processing components that are next assembled in a dataflow graph through a Python script. At runtime the graph is instantiated according to the execution context, FlowVR taking care of deploying the application on the target architecture, and of coordinating the analytics workflows with the simulation execution.

But today the choice of the resource allocation strategy is mostly ad-hoc and defined by the programmer. We will investigate solutions that enable a cooperative use of the resource between the analytics and the simulation with minimal hints from the programmer. In situ processings inherit from the parallelization scale and data distribution adopted by the simulation, and must execute with minimal perturbations on the simulation execution (whose actual resource usage is difficult to know a priori). We need to develop adapted scheduling strategies that operate at compile and run time. Because analysis are often data intensive, such solutions must take into consideration data movements, a point that classical scheduling strategies designed first for compute intensive applications often overlook. We expect to develop new scheduling strategies relying on the methodologies developed in Sec. 4.1.5. Simulations as well as analysis are iterative processes exposing a strong spatial and temporal coherency that we can take benefit of to anticipate their behavior and then take more relevant resources allocation strategies, possibly based on advanced learning algorithms or as developed in Section 4.1.

In situ analytics represent a specific workload that needs to be scheduled very closely to the simulation, but not necessarily active during the full extent of the simulation execution and that may also require to access data from previous runs (stored in the file system or on specific burst-buffers). Several users may also need to run concurrent analytics pipe-lines on shared data. This departs significantly from the traditional batch scheduling model, motivating the need for a more elastic approach to resource provisioning. These issues will be conjointly addressed with research on batch scheduling policies (Sec. 4.1).

4.3.3 Co-Design with Data Scientists

Given the importance of users in this context, it is of primary importance that in situ tools be co-designed with advanced users, even if such multidisciplinary collaborations are challenging and require constant long term investments to learn and understand the specific practices and expectations of the other domain.

We will tightly collaborate with scientists of some application domains, like molecular dynamics or fluid simulation, to design, develop, deploy and assess in situ analytics scenarios.

7.1.1 OAR

• Keywords:
  HPC, Cloud, Clusters, Resource manager, Light grid
• Scientific Description:
  This batch system is based on a database (PostgreSQL (preferred) or MySQL), a script language (Perl) and an optional scalable administrative tool (e.g. Taktuk). It is composed of modules which interact mainly via the database and are executed as independent programs. Therefore, formally, there is no API, the system interaction is completely defined by the database schema. This approach eases the development of specific modules. Indeed, each module (such as schedulers) may be developed in any language having a database access library.
• Functional Description:
  OAR is a versatile resource and task manager (also called a batch scheduler) for HPC clusters, and other computing infrastructures (like distributed computing experimental testbeds where versatility is a key).
• URL:
  http://­oar.­imag.­fr
• Contact:
  Olivier Richard
• Participants:
  Bruno Bzeznik, Olivier Richard, Pierre Neyron
• Partners:
  LIG, CNRS, Grid'5000, CIMENT, UAR GRICAD

7.1.2 MELISSA

• Keywords:
  Sensitivity Analysis, HPC, Data assimilation, Exascale
• Functional Description:
  Melissa is a middleware framework for on-line processing of data produced from large scale ensemble runs (parameter sweep data analysis). Initial developments focused on sensibility analysis, Melissa relying on iterative statistics to provide a file avoiding, fault tolerant and elastic framework. Largest runs so far involved up to 30k core, executed 80 000 parallel simulations, and generated 288 TB of intermediate data that did not need to be stored on the file system. Melissa was next extended to large scale data assimilation, with the integration of a simulation (or member) virtualization mechanism that enables to abstract the number of members from the actual resource allocations, further improving execution efficiency and elasticity. Latest contribution is support for training deep surrogate models with support for Phytorch and Tensorflow
• URL:
  https://­gitlab.­inria.­fr/­melissa
• Publications:
  hal-04145897, hal-04213978, hal-04102400, hal-01383860, hal-01607479, hal-03017033, hal-03927612, hal-03842106
• Authors:
  Theophile Terraz, Bruno Raffin, Alejandro Ribes, Bertrand Iooss
• Contact:
  Bruno Raffin
• Partner:
  Edf

7.1.3 NixOS-Compose

• Keywords:
  Infrastructure software, Deployment, High performance computing, Distributed computing
• Functional Description:
  NixOS-Compose simplifies the process of setting up ephemeral distributed systems by utilizing Nix's functional package management and NixOS's declarative configuration management. The tool facilitates testing, development, infrastructure prototyping, benchmarking, and advanced experiments in high-performance computing by providing easy and reproducible software stack deployment.
• URL:
  https://­gitlab.­inria.­fr/­nixos-compose/­nixos-compose
• Publication:
  hal-03723771
• Contact:
  Olivier Richard
• Partners:
  LIG, CNRS, UGA

7.1.4 Batsim

• Keywords:
  Simulation, Distributed systems
• Functional Description:
  BatSim is a Resource and Job Management System (RJMS) framework simulator based on SimGrid. It aims at taking into account platform's hardware capabilities and impacts in simulations. Also, schedulers parts are plugable through a comprehensive API and they are seen as external component of the framework.
• Release Contributions:
  see https://batsim.readthedocs.io/en/latest/changelog.html
• URL:
  https://­batsim.­readthedocs.­io/­en/­latest/
• Contact:
  Olivier Richard
• Partner:
  IRIT

7.2.1 SILECS/Grid'5000 and Meso Center Ciment

We are very active in promoting the factorization of compute resources at a regional and national level. We have a three level implication, locally to maintain a pool of very flexible experimental machines (hundreds of cores), regionally through the CIMENT meso center, and nationally by contributing to the SILECS/Grid'5000 platform, our local resources being included in this platform. Olivier Richard is member of SILECS/Grid'5000 scientific committee. The OAR scheduler in particular is deployed on both infrastructures. DataMove is hosting several ingineers dedicated to Grid'5000 support.

8.1.1 Multi-objective Scheduling Policy for Serverless-based Edge-Cloud Continuum

The cloud is extended towards the edge to form a computing continuum while managing resources' heterogeneity. The serverless technology simplified how to build cloud applications and use resources, becoming a driving force in consolidating the continuum with the deployment of small functions with short execution. However, the adaptation of serverless to the edge-cloud continuum brings new challenges mainly related to resource management and scheduling. Standard cloud scheduling policies are based on greedy algorithms that do not efficiently handle platforms' heterogeneity nor deal with problems such as cold start delays. This work introduces a new scheduling policy that tries to address these issues. It is based on multi-objective optimization for data transfers and makespan while considering heterogeneity. Using simulations that vary workloads, platforms, and heterogeneity levels, we study the system utilization, the trade-offs between the targets, and the impacts of considering platforms' heterogeneity. We perform comparisons with a baseline inspired by a Kubernetes-based policy, representing greedy algorithms. Our experiments show considerable gaps between the efficiency of a greedy-based scheduling policy and a multi-objective-based one. The last outperforms the baseline by reducing makespan, data transfers, and system utilization by up to two orders of magnitudes in relevant cases for the edge-cloud continuum 8.

8.1.2 Primal-Dual Algorithms with Predictions for Online Bounded Allocation and Ad-Auctions Problems

Designing online algorithms with predictions is a recent technique for various practically relevant online problems (scheduling, caching (paging), clustering, ski rental, etc.). The unified approach through a primal-dual framework for linear covering problems extends the online primal-dual method by incorporating predictions, and its performance goes beyond the worst-case analysis. Following this research line, we developped competitive algorithms with predictions for non-linear covering problems, generalizing the previous technique. We illustrate the applicability of our algorithms through experiments on energy minimization, congestion management, and submodular minimization problems 20.

8.1.3 Optimization Metrics for the Evaluation of Batch Schedulers in HPC

Machine Learning techniques are taking a prominent position in the design of system softwares. In HPC, many work are proposing to use such techniques (specifically Reinforcement Learning) to improve the performance of batch schedulers. Their main limitation is the lack of transparency of their decision. This underlines the importance of choosing correctly the optimization criteria when evaluating these solutions. In this work, we discuss bias and limitations of the most frequent optimization metrics in the literature. We provide elements on how to evaluate performance when studying HPC batch scheduling. We also propose a new metric: the standard deviation of the utilization, which we believe can be used when the utilization reaches its limits. We then experimentally evaluate these limitations by focusing on the use-case of runtime estimates. One of the information that HPC batch schedulers use to schedule jobs on the available resources is user runtime estimates: an estimation provide by the user of how long their job will run on the machine. These estimates are known to be inaccurate, hence many work have focused on improving runtime prediction 10.

8.2.1 Comparing Software-based Power Meters

The global energy demand for digital activities is constantly growing. Computing nodes and cloud services are at the heart of these activities. Understanding their energy consumption is an important step towards reducing it. On one hand, physical power meters are very accurate in measuring energy but they are expensive, difficult to deploy on a large scale, and are not able to provide measurements at the service level. On the other hand, power models and vendor-specific internal interfaces are already available or can be implemented on existing systems. Plenty of tools, called software-based power meters, have been developed around the concepts of power models and internal interfaces, in order to report the power consumption at levels ranging from the whole computing node to applications and services. However, we have found that it can be difficult to choose the right tool for a specific need. In this work, we qualitatively and experimentally compare several software-based power meters able to deal with CPU or GPU-based infrastructures. For this purpose, we evaluate them against high-precision physical power meters while executing various intensive workloads. We extend this empirical study to highlight the strengths and limitations of each software-based power meter 16.

8.2.2 Optimal Sizing of a Globally Distributed Low Carbon Cloud Federation

The carbon footprint of IT technologies has been a significant concern in recent years. This concern mainly focuses on the electricity consumption of data centers; many cloud suppliers commit to using 100% of renewable energy sources. However, this approach neglects the impact of device manufacturing. We consider the question of dimensioning the renewable energy sources of a geographically distributed cloud with considering the carbon impact of both the grid electricity consumption in the considered locations and the manufacturing of solar panels and batteries. We design a linear program to optimize cloud dimensioning over one year, considering worldwide locations for data centers, real-life workload traces, and solar irradiation values. Our results show a carbon footprint reduction of about 30% compared to a cloud fully supplied by solar energy and of 85% compared to the 100% grid electricity model 19.

8.2.3 A Methodology and a Toolbox to Explore Dataset related to the Environmental Impact of HTTP Requests

EcoIndex has been proposed to evaluate the absolute environmental performance of a given URL using a score ranging from 0 to 100 (the higher, the better). We make a critical analysis of the initial approach and propose alternatives that no longer calculate a plain score but allow the query to be situated among other queries. The generalized critiques come with statistics and rely on extensive experiments (first contribution). Then, we move on to low-cost Machine Learning (ML) approaches (second contribution) and a transition before obtaining our final results (third contribution). Our research aims to extend the initial idea of analytical computation, i.e., a relation between three variables, in the direction of algorithmic ML computations. The fourth contribution corresponds to a discussion on our implementation, available on a GitHub repository. We also examine the question: What attributes make sense for our problem?, or equivalently, what is a relevant data policy for studying digital environmental impacts? Beyond computational questions, it is important for the scientific community to focus on this question in particular. We currently promote using well established ML techniques because of their potential. However, we also question techniques for their frugality or otherwise. Our data science project is still at the data exploration stage. We also want to encourage synergy between technical expertise and business knowledge because this is fundamental for advancing the data project 12.

8.2.4 Social and Environmental Effects of Post-COVID-19 Computer Science Virtual Conferencing: The Euro-Par Case

Conferencing is one of the main pillars of Computer Science research activity regarding career and networking, with conference publications playing a more pronounced role compared to other disciplines. The COVID-19 pandemic forced us to switch to virtual conferencing, and many works have shown the benefits of virtual conferencing in terms of inclusivity and reduction of Green House Gas emissions. We are moving toward the usual conferencing format as it appears that the pandemic is increasingly under control. However, the changes imposed during the period of the pandemic brought many essential lessons regarding conferencing social and environmental effects. A crucial task is to gather these community experiences to give directions on how to keep the learned lessons post-COVID-19. We used the Euro-Par conference to combine these lessons in the Computer Science case. We show practical results that reinforce the marginal emissions of virtual conferencing compared to in-person conference travel. We also open the debate that rethinking the conference utility according to our objectives (scientific and ecologic) and being aware of social/geographical biases are essential factors in participating and organizing post-COVID-19 conferences 11.

8.3.1 Taenite : Seamless Persistant Memory Management with Rust

We introduce Taenite 21, a transactional programming library designed for persistent memory. Utilizing the copy-on-write principle, it enables us to circumvent the necessity for logs and, simultaneously, affirms the atomicity of all modifications at the conclusion of a transaction. Data consistency is assured at all times, and recovery after failures is instantaneous. Its programming interface, closely resembling that of the Rust standard library, facilitates simple and transparent usage. We elaborate on its operational principle and, in particular, its memory allocator. Starting from elementary components, we establish the construction of intricate persistent structures such as tree structures, for example, hitchhiking trees or DAGs.

8.3.2 Deisa: In Transit Data Analytics with Dask

We are working with CEA (PhD of Amal Gueroudji) to enable in situ processing for the Dask distributed task programming environment. We developped a hybrid model called DEISA, that supports coupling MPI parallel codes with analyses written using Dask. This implementation requires minimal modifications of both the simulation and analysis codes compared to their post hoc counterpart, while giving access to parallel versions of Numpy, Pandas and scikit-learn 15, 27.

8.3.3 Deep Surrogate Training

Recent years have seen a surge in deep learning approaches to accelerate numerical solvers, which provide faithful but computationally intensive simulations of the physical world. These deep surrogates are generally trained in a supervised manner from limited amounts of data slowly generated by the same solver they intend to accelerate. We extend the Melissa framewrok to enable the online training of these models from a large ensemble run of simulations. It leverages multiple levels of parallelism to generate rich datasets. The framework avoids I/O bottlenecks and storage issues by directly streaming the generated data. A training reservoir mitigates the inherent bias of streaming while maximizing GPU throughput. Experiment on training a fully connected network as a surrogate for the heat equation shows the proposed approach enables training on 8TB of data in 2 hours with an accuracy improved by 47% and a batch throughput multiplied by 13 compared to a traditional offline procedure 17, 7. Other experiments with various neural architectures indicate that more dataset diversity, up to hundreds of GB, can increase deep surrogate generalization capabilities. Fully connected neural networks, Fourier Neural Operator (FNO), and Message Passing PDE Solver prediction accuracy is improved by 68%, 16% and 7%, respectively 18.

Following up on this approach of online deep surrogate training, we are also investigating active learning methods for training neural networks from synthetic input samples that can be generated on-demand. This includes Physics Informed Neural Networks (PINNs), simulation-based inference, deep surrogates and deep reinforcement learning. An adaptive process observes the training progress and steers the data generation with the goal of speeding up and increasing the quality of training. We proposed a novel adaptive sampling method that concentrates samples close to the areas showing high loss values. Compared to the state-ofthe-art R3 sampling our algorithm converges to a validation loss of 0.5 in 6000 iterations, while it takes 25000 iterations to reach a loss of 0.7 for the R3 algorithm when training a PINN with the Allen Cahn equation 14.

10.1.1 LIGHTAIGE

• Program:
  SKŁODOWSKA-CURIE ACTIONS - Individual Fellowship
• Duration:
  November 2023 - December 2023
• Followship Recipient:
  Danilo Carastan-Santos
• Abstract:
  The goal of the LIGHTAIGE project is to approach the orchestration and simulation problems of Edge Intelligence with cross­discipline, lightweight ang transparent methods to minimize the GHG emissions – measured as the amount of equivalent CO2 emissions – of using Edge Intelligence.

10.1.2 REGALE

• Title:
  REGALE (An open architecture to equip next generation HPC applications with exascale capabilities)
• Program:
  EuroHPC Horizon 2020 research and innovation program
• Duration:
  From April 1, 2021 to March 31, 2024
• Partners:
  • Institut National de Recherche en Informatique et Automatique (INRIA), France
  • Institut Polytechnique de Grenoble (INP Grenoble), France
  • Ryax Technologies (Ryax Technologies), France
  • Électricité de France (EDF), France
  • Ethnicon Metsovion Polytechnion (National Technical Univesity of Athens - NTUA), Greece
  • Technische Universitaet Muenchen (TUM), Germany
  • Gioumpitek Meleti Schediasmos Ylopoiisi Kai Polisi Ergon Pliroforikis Etaireia Periorismenis Efthynis (Ubitech Design Planning Implementation and Sale of Information Works), Greece
  • Bayerische Akademie Der Wissenschaften (BADW), Germany
  • Université Grenoble Alpes (UGA), France
  • E 4 Computer Engineering SPA (E4), Italy
  • BULL SAS (BULL), France
  • TWT GMBH Science and Innovation (TWT GMBH Science and Innovation), Germany
  • Alma Mater Studiorum - Universita di Bologna (UNIBO), Italy
  • SCIO IKE (SCIO P.C.), Greece
  • Cineca Consorzio Interuniversitario (CINECA), Italy
  • Erevnitiko Panepistimiako Institouto Systimaton Epikoinonion Kai Ypologiston (Research University Institute of Communication and Computer Systems), Greece
  • Andritz Hydro GMBH, Austria
  • Barcelona Supercomputing Center, Centro Nacional de Supercomputacion (BSC CNS), Spain
• Coordinator for UGA/INRIA:
  Pierre-François Dutot
• Datamove Budget:
  680K euros.
• Summary:

  With exascale systems almost outside our door, we need now to turn our attention on how to make the most out of these large investments towards societal prosperity and economic growth. REGALE aspires to pave the way of next-generation HPC applications to exascale systems. To accomplish this we define an open architecture, build a prototype system and incorporate in this system appropriate sophistication in order to equip supercomputing systems with the mechanisms and policies for effective resource utilization and execution of complex applications.

  REGALE brings together leading supercomputing stakeholders, prestigeous academics, top European supercomputing centers and end users from five critical target sectors, covering the entire value chain in system software and applications for extreme scale technologies.

10.2.1 PEPR NUMPEX

• Goals:
  The main objective of the NumPEx (Numeric for Exascale) program in France is to develop state-of-the-art skills and infrastructures in the field of exascale computing.
• Duration:
  From 2023 to 2030
• Web site:
  NUMPEX
• Datamove implication:
  • Exa-DoST (Data-oriented Software and Tools for the Exascale): Co-lead WP3.
  • Exa-AToW (Architectures and Tools for Large-Scale Workflows): Co-lead WP5.
  • Exa-DI (Development and integration): CO-lead WP3.
• Datamove budget:
  1.295 M euros.

10.2.2 BPI

• Projet AMI Cloud OTPaaS (2021-2024). Aims at offering a new Cloud offer, compatible with Gaia-X and easy to use, that could favour the massive digital transition of companies. Datamove Budget: 110 Keuro.

10.2.3 ANR

• PPR Océan et Climat MEDIATION (2022-2030). Methodological developments for a robust and efficient digital twin of the ocean. Pi: INRIA team AIRSEA. Partners: INRIA, CNRS, IFREMER, IRD, Université Aix-Marseille, Institut National Polytechnique de Toulouse, Ecole Nationale Supérieure Mines-Télécom Atlantique Bretagne Pays de la Loire, Service Hygrodgraphique et Océanographique de la Marine, Université Grenoble Alpes, Météo-France-DESR-Centre National de Recherches Météorologiques. Total budget: 2,4 Meuros. Datamove Budget: 110 Keuros. CO-lead of the WP Leveraging AI and HPC for Digital Twins of the Ocean.

10.2.4 Univ. Grenoble Alpes

• Edge Intelligence chair of the Institute of Artificial Intelligence of Univ. Grenoble Alpes (MIA@Grenoble-Alpes) (2019-2023). PI: Denis Trystram. The challenges are to design new machine learning methods that fully exploit the distributed character of the edge and to develop algorithms and subsequent pieces of software that will allow the deployment of the edge/fog hybrid infrastructures. The research agenda is two-fold. In the first hand, we study new methods for distributed machine learning and data analytic. In the second hand, we develop the models and mechanisms for the orchestration of efficient local resource management. Budget: 335K euro
• IRS SoSCloud. Dimensioning of green energy in Clouds, 2020-2023. UGA Grant. PhD funding. Co-advised by D. Cordeiro, USP, Brasil. Budget : 120 Keuros

11.1.1 Scientific events: organisation

• Organization of the second Journées de Recherche en Apprentissage Frugal at Grenoble.
• Organizing committee of ISAV 2023. In Situ Infrastructures for Enabling Extreme-scale Analysis and Visualization. Workshop from SC23.

11.1.2 Scientific events: selection

11.4.1 Articles and contents

• EcoIndex : que vaut cet outil qui mesure le score environnemental des sites web ? The Conversation. May 2023.
• « L’envers des mots » : Exascale. The Conversation. Nov. 2023.
• Les défis d’une IA frugale. Journal du CNRS. Nov. 2023.

11.4.2 Interventions

• La RO face au réchauffement climatique : opportunité ou menace ?. Congrès ROADEF, Rennes – 22/02/2023.
• Paver la route pour une RO (plus) verte.Keynote Green Days, Lyon – 28/03/2023.
• Why current Batch Schedulers are not sustainable. Workshop Chicago, Paris – 29/03/2023.
• Impacts écologiques de l'IA. Journée GdR RADIA IA et sobriété, Paris – 4/04/2023.
• Transformations numériques éco-responsables.Webminaire UGA, Grenoble – 6/04/2023.
• L’apprentissage automatique opportunit ́e ou frein pour sortir de la crise climatique? Séminaire FEMPTO, Besançon – 4/05/2023.
• Doit-on croire dans le numérique pour sortir de la crise climatique ? Séminaire LIP6, Paris – 26/05/2023
• Quizz Eco Info. Program off ICT4S, Rennes – 6/06/2023
• Environmental issues of AI. Course EFELIA, Grenoble –11/07/2023
• Ecological impacts of AI. Summer School RSD on distributed learning, Lyon – 19/09/2023
• Atelier médiation. Journée Eco-Info, Saint Malo – 10/10/2023
• Enjeux écologiques de l'IA – Un état des lieux. Journées thématiques nationales CUME, Paris – 22/11/2023

International journals

• 7 articleM.Marc Schouler, R. A.Robert Alexander Caulk, L.Lucas Meyer, T.Théophile Terraz, C.Christoph Conrads, S.Sebastian Friedemann, A.Achal Agarwal, J. M.Juan Manuel Baldonado, B.Bartłomiej Pogodziński, A.Anna Sekuła, A.Alejandro Ribes and B.Bruno Raffin. Melissa: coordinating large-scale ensemble runs for deep learning and sensitivity analyses.Journal of Open Source Software886June 2023, 5291HALDOIback to text

International peer-reviewed conferences

• 8 inproceedingsL.Luc Angelelli, A. A.Anderson Andrei da Silva, Y.Yiannis Georgiou, M.Michael Mercier, G.Grégory Mounié and D.Denis Trystram. Towards a Multi-objective Scheduling Policy for Serverless-based Edge-Cloud Continuum.CCGrid 2023 - 23rd IEEE/ACM International Symposium on Cluster, Cloud and Internet ComputingBangalore, IndiaIEEEMay 2023, 485-497HALDOIback to text
• 9 inproceedingsA.Adrien Berthelot, E.Eddy Caron, M.Mathilde Jay and L.Laurent Lefèvre. Estimating the environmental impact of Generative-AI services using an LCA-based methodology.Procedia CIRPCIRP LCE 2024 - 31st Conference on Life Cycle EngineeringTurin, Italy2024, 1-10HAL
• 10 inproceedingsR.Robin Boëzennec, F.Fanny Dufossé and G.Guillaume Pallez. Optimization Metrics for the Evaluation of Batch Schedulers in HPC.JSSPP 2023 - 26th edition of the workshop on Job Scheduling Strategies for Parallel ProcessingSt. Petersburg, Florida, United StatesMarch 2023, 1-19HALback to text
• 11 inproceedingsD.Danilo Carastan-Santos, K.Krzysztof Rzadca, L.Leonel Sousa and D.Denis Trystram. Social and environmental effects of post-COVID-19 Computer Science virtual conferencing: The Euro-Par case.2023 International Conference on ICT for Sustainability (ICT4S)Rennes, FranceIEEEJune 2023, 132-141HALDOIback to text
• 12 inproceedingsC.Christophe Cérin, M.Mathilde Jay, L.Laurent Lefèvre and D.Denis Trystram. A Methodology and a Toolbox to Explore Dataset related to the Environmental Impact of HTTP Requests.2023 IEEE International Conference on Big Data (BigData) - 3rd International Workshop on Big Data Analytics for SustainabilitySorrento (Naples), ItalyIEEE2024, 1-10HALDOIback to text
• 13 inproceedingsP.-F.Pierre-François Dutot, Y.-S.Yeu-Shin Fu, N.Nikhil Prasad and O.Oliver Sinnen. A Guaranteed Approximation Algorithm for Scheduling Fork-Joins with Communication Delay.2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS),2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS)St. Petersburg, United StatesIEEE2023, 820-830HALDOI
• 14 inproceedingsS.Sofya Dymchenko and B.Bruno Raffin. Loss-driven sampling within hard-to-learn areas for simulation-based neural network training.MLPS 2023 - Machine Learning and the Physical Sciences Workshop at NeurIPS 2023 - 37th conference on Neural Information Processing SystemsNew Orleans, United States2023, 1-5HALback to text
• 15 inproceedingsA.Amal Gueroudji, J.Julien Bigot, B.Bruno Raffin and R.Robert Ross. Dask-Extended External Tasks for HPC/ML In Transit Workflows.SC-W 2023 - Workshops of The International Conference on High Performance Computing, Network, Storage, and AnalysisDenver, United StatesACMNovember 2023, 831-838HALDOIback to text
• 16 inproceedingsM.Mathilde Jay, V.Vladimir Ostapenco, L.Laurent Lefèvre, D.Denis Trystram, A.-C.Anne-Cécile Orgerie and B.Benjamin Fichel. An experimental comparison of software-based power meters: focus on CPU and GPU.CCGrid 2023 - 23rd IEEE/ACM international symposium on cluster, cloud and internet computingBangalore, IndiaIEEE2023, 1-13HALDOIback to text
• 17 inproceedingsL.Lucas Meyer, M.Marc Schouler, R. A.Robert Alexander Caulk, A.Alejandro Ribés and B.Bruno Raffin. High Throughput Training of Deep Surrogates from Large Ensemble Runs.SC '23: Proceedings of the International Conference on High Performance Computing, Networking, Storage and AnalysisSC 2023 - The International Conference for High Performance Computing, Networking, Storage, and AnalysisDenver, CO, United StatesACMNovember 2023, 1-14HALDOIback to text
• 18 inproceedingsL.Lucas Meyer, M.Marc Schouler, R. A.Robert Alexander Caulk, A.Alejandro Ribés and B.Bruno Raffin. Training Deep Surrogate Models with Large Scale Online Learning.Proceedings of Machine Learning ResearchInternational Conference on Machine Learning202Honolulu (Hawai'i), United StatesJuly 2023, 24614-24630HALback to text
• 19 inproceedingsM. F.Miguel Felipe Silva Vasconcelos, D.Daniel Cordeiro, G.Georges da Costa, F.Fanny Dufossé, J.-M.Jean-Marc Nicod and V.Veronika Rehn-Sonigo. Optimal sizing of a globally distributed low carbon cloud federation.CCGrid 2023 - IEEE/ACM 23rd International Symposium on Cluster, Cloud and Internet ComputingBangalore, India2023, 1-13HALDOIback to text
• 20 inproceedingsN. K.Nguyễn Kim Thắng and E.Enikő Kevi. Primal-Dual Algorithms with Predictions for Online Bounded Allocation and Ad-Auctions Problems.ALT 2023 - 34th International Conference on Algorithmic Learning TheorySingapore, Singapore2023, 1-18HALback to text

National peer-reviewed Conferences

• 21 inproceedingsL.Louis Boulanger, F.Frédéric Wagner and Y.Yves Denneulin. Taenite : Gestion transparente de la mémoire persistante en Rust.COMPAS 2023 - Conférence francophone d'informatique en Parallélisme, Architecture et SystèmeAnnecy, France2023, 1-7HALback to text
• 22 inproceedingsE.Ernest Foussard, G.Gérémi Bridonneau, M.-L.Marie-Laure Espinouse, G.Grégory Mounié and M.Margaux Nattaf. Génération de colonnes pour le Bin-Packing avec seuils.ROADEF 2023 - 24ème congrès annuel de la Société Française de Recherche Opérationnelle et d'Aide à la DécisionRennes, FranceFebruary 2023HAL
• 23 inproceedingsQ.Quentin Guilloteau, A.Adrien Faure, M.Millian Poquet and O.Olivier Richard. Comment rater la reproductibilité de ses expériences ?ComPAS 2023 Conférence francophone en informatique1-9Annecy, FranceJuly 2023, à paraîtreHAL

Conferences without proceedings

• 24 inproceedingsP.-F.Pierre-François Dutot. REGALE project: Oar, A Versatile Resource and JobManagement System.CONCERTO 2024 - 2nd workshop on projeCts crOss-synergy iN advanCing Exascale platfoRms and quanTum cOmputingMunich, Germany2024HAL
• 25 inproceedingsL.Lucas Rosa, D.Danilo Carastan-Santos and A.Alfredo Goldman. An experimental analysis of regression-obtained HPC scheduling heuristics.Job Scheduling Strategies for Parallel Processing14283Lecture Notes in Computer ScienceSt. Petersburg, United StatesSpringer Nature SwitzerlandSeptember 2023, 116-136HALDOI

Doctoral dissertations and habilitation theses

• 26 thesisV.Vincent Fagnon. Prediction and resource augmentation come to the rescue of algorithmics..Université Grenoble Alpes [2020-....]July 2023HAL
• 27 thesisA.Amal Gueroudji. Distributed Task-Based In Situ Data Analytics for High-Performance Simulations.Université Grenoble Alpes [2020-....]May 2023HALback to text
• 28 thesisQ.Quentin Guilloteau. Control-based runtime management of HPC systems with support for reproducible experiments.Université Grenoble AlpesDecember 2023HAL

Reports & preprints

• 29 miscR.Robin Boëzennec, F.Fanny Dufossé and G.Guillaume Pallez. Analyzing Qualitatively Optimization Objectives in the Design of HPC Resource Manager.August 2023HAL
• 30 miscS.Sebastian Friedemann, K.Kai Keller, Y.-S.Yen-Sen Lu, B.Bruno Raffin and L.Leonardo Bautista Gomez. Dynamic Load/Propagate/Store for Data Assimilation with Particle Filters on Supercomputers.2024HALDOI
• 31 miscQ.Quentin Guilloteau, O.Olivier Richard, R.Raphaël Bleuse and E.Eric Rutten. Folding a Cluster containing a Distributed File-System.2023HAL
• 32 miscQ.Quentin Guilloteau. Simulating a Multi-Layered Grid Middleware.May 2023HAL
• 33 miscE.Enikő Kevi and N. K.Nguyễn Kim Thắng. Online Covering with Multiple Experts.November 2023HAL
• 34 miscE.Enikő Kevi and N. K.Nguyễn Kim Thắng. Online Primal-Dual Algorithm with Predictions for Non-Linear Covering Problems.December 2023HAL
• 35 miscL.Laurent Lefèvre, A.-L.Anne-Laure Ligozat, D.Denis Trystram, S.Sylvain Bouveret, A.Aurélie Bugeau, J.Jacques Combaz, E.Emmanuelle Frenoux, G.Gaël Guennebaud, J.Julien Lefèvre, J.-P.Jean-Philippe Nicolaï and K.Karin Dassas. Environmental assessment of projects involving AI methods.January 2023HAL
• 36 miscG.Guillaume Raffin and D.Denis Trystram. Dissecting the software-based measurement of CPU energy consumption: a comparative analysis.January 2024HAL
• 37 reportA.Alena Shilova, T.Thomas Delliaux, P.Philippe Preux and B.Bruno Raffin. Learning HJB Viscosity Solutions with PINNs for Continuous-Time Reinforcement Learning.RR-9541Inria Lille - Nord Europe, CRIStAL - Centre de Recherche en Informatique, Signal et Automatique de Lille - UMR 9189; Univ. Lille, CNRS, Centrale Lille, Inria UMR 9189 - CRIStAL,INRIA Lille Nord Europe, Villeneuve d’Ascq, France; Univ. Grenoble Alps, CNRS, Inria, Grenoble INP, LIG, 38000 Grenoble, FranceFebruary 2024, 1-30HAL

Other scientific publications

• 38 thesisS.Samuel Brun. Étude du phénomène Stat-Storm - Limitation des appels systèmes pour les systèmes de fichiers distribués de type store.Université Grenoble AlpesSeptember 2023HAL
• 39 miscA. A.Anderson Andrei Da Silva, Y.Yiannis Georgiou, M.Michael Mercier, G.Grégory Mounié and D.Denis Trystram. Towards Container-layer-aware Scheduling Policies for Serverless-based Edge-Cloud Continuum.Brno, Czech RepublicJune 2023HAL
• 40 miscA. A.Anderson Andrei Da Silva, Y.Yiannis Georgiou, M.Michael Mercier, G.Grégory Mounié and D.Denis Trystram. Towards an Energy-Aware Multi-objective Scheduling Policy for Server-based Edge-Cloud Continuum.Annecy, France2023, 1-21HAL
• 41 miscS.Simon Delamare, D.David Margery, P.Pierre Neyron and L.Lucas Nussbaum. Évolution du matériel et des services logiciels disponibles dans Grid’5000.May 2023HAL
• 42 inproceedingsS.Sofya Dymchenko and B.Bruno Raffin. Loss-driven sampling for online neural network training with large scale simulations.LIG PhD day 2023Grenobe, France2023, 1-1HAL
• 43 thesisA.Alexandre Lithaud. Contribution au projet NixOS Compose.Université Grenoble AlpesSeptember 2023, 1-39HAL