# Stochastic Model Predictive Control with Direct Feedforward Compensation: Harvesting Idle Resources in High-Performance Computing

Kouds Halitim*, Bogdan Robu†, Sophie Cerf‡, Raphaël Bleuse*, Éric Rutten*

*Univ. Grenoble Alpes, Inria, CNRS, Grenoble INP, LIG, F-38000 Grenoble, France

†Univ. Grenoble Alpes, CNRS, Grenoble INP, Gipsa-lab, F-38000 Grenoble, France

‡Univ. Lille, Inria, CNRS, Centrale Lille, UMR 9189 CRISTAL, F-59000 Lille, France

E-mail: †first.last@univ-grenoble-alpes.fr * , ‡first.last@inria.fr

**Abstract**—In high-performance computing (HPC), many research has been conducted on how to efficiently utilize the idle time of HPC resources (periods when no jobs are submitted to the platform). One promising approach is to exploit this idle time by injecting small, flexible, independent, and interruptible jobs that have no strict time constraints. However, managing the injection of these jobs is challenging due to the stochastic nature of job parameters, such as execution times and resource consumption. Additionally, process noise—resulting from system complexity and the arrival and execution of varying external workloads—can interrupt or terminate these filler jobs. In this paper, we propose and evaluate, using real data, a Stochastic Model Predictive Control (SMPC) approach that addresses system uncertainty and incorporates a feed-forward compensation mechanism for disturbance rejection. The proposed algorithm shows promising results: it ensures a platform usage rate of 98%, significantly improving overall resource efficiency and reducing the number of early terminated jobs compared to previous work.

***Index Terms***—High-Performance Computing, resource management, Stochastic Model Predictive Control, Feedforward, energy efficiency.

## I. INTRODUCTION

High Performance Computing (HPC) refers to the technologies, methods, and applications used to achieve the highest possible computing power at any given time. It uses large, interconnected machines—called supercomputers—to perform a wide array of computational problems, commonly referred to as applications or workloads, submitted by the users of the infrastructure as fast as possible [1]. Because these systems are so powerful, they also consume a large amount of energy. Recent estimates show that the total power used by the world’s top supercomputers is extremely high. For example, if each of the TOP500 systems used around 30 MW—similar to leading machines—the total demand would reach about 15 GW, roughly the output of 15 nuclear power plants [2]. This massive energy demand, combined with growing global investments in HPC and large-scale data centers [3], makes energy-efficient resource management not just beneficial but essential. At this scale, even small gain or improvement in efficiency can translate into enormous reductions in electricity

use and operating costs—potentially saving millions of dollars annually while also reducing environmental impact.

Existing HPC platforms suffer from *idle time*, which refers to periods when computational resources—such as CPUs or GPUs—are not actively executing tasks due to gaps between job executions. During these idle periods, systems may enter low-power states to conserve energy. For instance, the Linux kernel’s CPU idle time management allows processors to enter idle states, reducing power consumption, but still studies have shown that idle power can range from 20% to 60% of the power consumed at maximum utilization [4], depending on the generation of technology, the system’s design and power management strategies. Similarly, adaptive power management techniques in HPC systems can lower the power state of idle nodes to reclaim unnecessary energy usage [5]. Moreover, idle time can be leveraged for other tasks. We use in this work Cigri, a computing grid middleware allowing for such leveraging [6], [7]. It is deployed in the GRICAD computing center [8]. It interacts with the OAR Resource and Job Management System (RJMS) [9] of each managed cluster: a group of interconnected machines working together as a single system.

The goal of CiGri is to use the idle resources of the entire computing grid to perform useful computing tasks. This is typically done by injecting low-priority tasks, such as Monte Carlo-like simulations. The jobs submitted to CiGri are HPC jobs, just with different “shapes” or resource profiles. A single RJMS decision handles the allocation of all jobs at the cluster level. This includes the *Best-Effort* (BE) jobs submitted through CiGri and the *High-Priority* (HP) jobs directly submitted through the RJMS.

CiGri’s current job submission mechanism functions like a “tap” that periodically releases a certain number of jobs into the system. It is important to design this mechanism carefully, as imprecise job submission can lead to inefficient use of resources—if too few jobs are submitted, resources may sit idle; if too many are submitted, BE jobs may be early terminated due to overload [7].

Several studies have proposed adding a feedback regulation
mechanism. Specifically, these works design controllers aimed at maximizing the utilization of idle resources by BE jobs, while simultaneously minimizing the negative effects of these filler jobs on shared cluster resources, particularly the file server. Various control strategies have been implemented, including Proportional-Integral (PI) controllers [10], Model-Free Control [11], Model Predictive Control (MPC) [12], and adaptive PI methods [13].

However, these works have several limitations. First, they typically do not feed the controller with information about the current cluster state (i.e, currently running jobs). This leads to under-utilization of the platform. Second, the system models use the execution time of BE jobs as a deterministic parameter, despite it being a highly stochastic variable subject to noise and uncertainty. Finally, these works do not account for the arrival of HP jobs, which can interrupt (terminate early) the BE jobs.

In this paper, to address the limitations identified in previous work, we propose a novel approach which applies stochastic modeling and predictive control to optimize BE jobs scheduling under uncertainty while accommodating HP jobs arrivals. The main contributions of this paper are as follows:

1) We propose a stochastic model predictive control (SMPC) design that accounts for the probabilistic distribution of the BE model's parameters.

2) We introduce a feed-forward compensation mechanism to handle the arrival of HP jobs.

The remainder of this paper is organized as follows: section II reviews existing related work; section III describes the system and formally states the problem; section IV introduces the model used; section V describes the proposed stochastic model predictive control strategy; section VI presents and discusses the experimental setup as well as the modeling and control results; finally, section VII concludes the paper, and section VIII outlines directions for future work.

## II. BACKGROUND

### A. Control for Computing

Feedback regulation of computing systems has emerged as a promising approach in autonomic computing [14] for managing the dynamic and unpredictable behavior of computing environments [15]. Control theory approaches have been widely used to regulate and optimize the behavior of various computing systems, including software applications [16], [17], [18], cloud infrastructures [19], [20], [21], and HPC environments [22], [23]. HPC systems, in particular, exhibit variability in workload arrivals, execution times, and resource consumption, often influenced by stochastic disturbances and external workloads. Traditional static or rule-based management strategies struggle to adapt effectively to these rapidly changing conditions which would benefit from run-time regulation under stability guarantees and robust rules.

### B. Resource Harvesting

HPC systems often experience periods of underutilization due to the exclusive allocation of resources to scheduled jobs.

To improve system efficiency, many studies have explored resource harvesting techniques that make use of idle resources without disrupting primary workloads. The motivation for harvesting idle computing resources is simple: unused machines waste energy and money, and using them can give users more computing power at a low cost. There exists many strategies to harvest unused resources: we presented in the introduction the injection of BE jobs. Przybylski et al. proposed using Function-as-a-Service (FaaS) workloads to operate alongside traditional HPC applications [24]. Mercier et al. worked on coupling HPC jobs and Big-Data workflows focusing on the challenges related to the scheduling of both Big Data and HPC workloads on the same computing platform [25].

### C. Stochastic Control

Stochastic Model Predictive Control (SMPC) [26] has been applied across a range of systems to handle uncertainty and support real-time decision-making. In cloud and data center environments, SMPC has been used for energy-efficient workload dispatching [27] which showed improved energy efficiency and cost savings compared to traditional deterministic dispatch strategies, especially under fluctuating renewable energy supply and workload demand. For other general systems, some works used learning-based SMPC that explicitly incorporates chance constraints to ensure reliable tracking under Gaussian and non-Gaussian uncertainties [28], [29], while other works used robust or scenario-based approaches that address uncertainty without formal probabilistic bounds [30], [31]. Collectively, these studies demonstrate the flexibility of SMPC in optimizing performance under general probabilistic uncertainty.

## III. SYSTEM DESCRIPTION

We first describe the architecture of the computing platform, the characteristics of the workloads, and the assumptions underlying our modeling approach. We also define the variables and parameters used throughout the paper.

### A. System Description

We consider a single HPC cluster composed of $r_{max}$ computing nodes, managed by a RJMS. The RJMS maintains information about available resources, job statuses, user submissions,

<figure><img src="image_1.png" /><figcaption>Fig. 1: System architecture of the HPC system integrating CiGri with feedback-based regulation of BE jobs. The RJMS has all information of all instances of waiting, running and scheduled jobs, the controller dynamically adjusts BE job submissions based on the platform status including HP and BE jobs running and waiting to make decisions on the submission size.</figcaption></figure>
and scheduling decisions. While computational resources can generally be represented as a vector of components (e.g., memory, CPU with multiple cores, GPU), we simplify the model by treating resources as a single scalar value corresponding to the number of computing nodes.

The RJMS manages two separate waiting queues: one for HP user jobs and another for BE jobs. BE jobs are submitted through CiGri to utilize idle resources where no HP jobs are running as shown in fig. 1. A BE job can exist in one of four states: running, waiting, early-terminated or completed.

* A job is in the running state $r^{BE}$ if it is currently executing on available resources.

* A job is in the waiting state $w^{BE}$ if it has been submitted but no resources are currently available. In this case, it stays in the waiting queue until enough resources become available.

* A job is early-terminated $\kappa^{BE}$ if it was running but had to be terminated before completion by the RJMS to free resources for a HP job. In this case, the BE job is sent back to the waiting queue to be rescheduled when resources become available.

* A job is completed if it successfully finished execution.

Each job is characterized mainly by two parameters: (i) its processing time which is provided as an estimate by the user, but subject to stochastic variability and modeled through a probabilistic distribution; and (ii) the number of requested resources, which is a deterministic variable specified by the user. The state of the platform evolves dynamically based on the arrival, execution, and termination of jobs. It is further influenced by noise, including competition for shared resources (e.g., file servers) and deployment overheads. These noises can extend jobs execution times, and make the platform behavior increasingly stochastic and unpredictable.

## B. Problem Formulation

The control objective is to dynamically regulate the number of submitted BE jobs, denoted as $u(k)$, at each discrete decision instant $k = nT_s$, where $T_s = 30$ s is the controller sampling period and $n \in \mathbb{N}$. The goal is to maximize the occupation of idle resources by BE jobs while minimizing the probability of their early termination.

To achieve this, the current state of the HPC platform is continuously monitored. The system output $y^{BE}(k)$ consists of the number of running $r^{BE}(k)$ and waiting $w^{BE}(k)$ BE jobs, while the arrival of HP jobs is treated as an exogenous disturbance input $d(k)$. The control input $u(k)$ is then adjusted at each sampling instant based on the system state.

For the purpose of control design, and to simplify the initial analysis, we make the following assumptions:

* In real world scenarios, users submit their BE jobs and provide an approximation $\tilde{p}_j^{BE}$ of their execution time (e.g, 30s, 60s, 240s...) [32]. However, the jobs submitted never last the precised time due to various factors such as overestimation by the user or deployment overhead. In our study, we submit campaigns of homogeneous jobs with a user-estimated $\tilde{p}_j^{BE} = 60$ s execution time. Data show

that the real execution time $p_j^{BE}$ of these jobs follow the distribution depicted on fig. 2.

* All jobs are represented by the number of resources they occupy: a job requesting $q_j$ resources is modeled directly as a $q_j$-resource job. BE jobs are assumed to be sequential, each occupying exactly one resource ($q_j^{BE} = 1$ resource), while HP jobs take $q_j^{HP}$ resources.

* The sequence of HP job arrivals is available via the RJMS sensor over a finite prediction horizon $\mathcal{H}$, including past, current, and future values. While such information may not always be available in practice, we consider the case where it is known, both to simplify the modeling and to explicitly incorporate HP arrivals as a known disturbance acting on the system.

<figure><img src="image_2.png" /><figcaption>Fig. 2: Histogram of the execution times for a CiGri campaign during the identification experiment [33]. The campaign is composed of synthetic jobs of a theoretical duration of 60 seconds each, as we can see from the distribution their actual duration is between 63 and 70 seconds.</figcaption></figure>

## IV. MODELING

1) Plant Model (BE Jobs): Concerning the BE jobs and following the previous assumptions and notations from section III-A, we build upon the model introduced in prior work [33]:

$$y^{BE}(k+1) = y^{BE}(k) + u(k) - c^{BE}(k) \quad (1)$$

where $y^{BE}(k) = r^{BE}(k) + w^{BE}(k)$, $r^{BE}(k)$ is the number of running BE jobs and the $w^{BE}(k)$ is the number of waiting jobs at every step $k$. The output of our system includes the term $c^{BE}(k)$ representing the completion rate of the BE jobs at each time step. This completion rate is defined as $c^{BE}(k) = \frac{\Delta t}{p_j^{BE}} \cdot r_{max}$ and highly depends on the execution time of BE jobs $p_j^{BE}$. $p_j^{BE}$ is a stochastic parameter modeled as truncated normal probability distribution, as shown in fig. 2, and is defined by the following equation:

$$p_j^{BE} \sim \mathcal{N}(\mu, \sigma^2), \quad \tilde{p}_j^{BE} \le p_j^{BE} < +\infty \quad (2)$$

where $\mu = 65$ s is the mean, $\sigma = 0.36$ s is the standard deviation in the execution time parameter, and $\tilde{p}_j^{BE} = 60$ s is the execution time approximated by the user.
We notice that the previous model is stable for values of $u \le c^{\text{BE}}$ and unstable for values of $u > c^{\text{BE}}$, where $c^{\text{BE}}$ is the approximated completion rate measured using the BE jobs execution time estimated by the user $\tilde{p}_j^{\text{BE}}$. This can be explained by submitting jobs more than the cluster can handle therefore the excess jobs accumulate and we notice a burst in the waiting queue. In the stable region, the queue dynamics are minimal and around zero. The previous process detailed in eq. (1) hence can be represented as an ARX model with a zero mean noise:

$$y^{\text{BE}}(k+1) = Ay^{\text{BE}}(k) + Bu(k) + D\varepsilon(k) \quad (3)$$

where $\varepsilon(k)$ is a zero-mean noise process capturing the unmodeled stochastic variability in the execution time described earlier. The matrices $A \in \mathbb{R}^{n_y \times n_y}$, $B \in \mathbb{R}^{n_y \times n_u}$, and $D \in \mathbb{R}^{n_y \times n_\varepsilon}$ are system parameters characterizing the system dynamics. The system matrices are of dimension $1 \times 1$ and are defined as:

$$A = [0.3 \quad B = [1.4] \quad D = [1]$$

The process noise $\varepsilon(k)$ is modeled as a normally distributed random variable $\varepsilon(k) \sim N(0, \text{Cov}_\varepsilon)$, with a covariance matrix:

$$\text{Cov}_\varepsilon = [4]$$

For the region of the input $u \ge c^{\text{BE}}$ where the queue shows nonlinear behavior, we use queuing theory to model the behavior of the system:

$$y^{\text{BE}}(k+1) = y^{\text{BE}}(k) + \text{arrivals}(k) - \text{served}(k) \quad (4)$$

By applying this to our system we have the following formulation:

$$\text{arrivals}(k) = u(k) \quad (5)$$

$$\text{served}(k) = \min(w^{\text{BE}}(k-1) + \text{arrivals}(k), c^{\text{BE}}(k)) \quad (6)$$

$$w^{\text{BE}}(k) = w^{\text{BE}}(k-1) + \text{arrivals}(k) - \text{served}(k) \quad (7)$$

$$y^{\text{BE}}(k) = \text{served}(k) + w^{\text{BE}}(k) \quad (8)$$

The system is subject to the following constraints:

$$0 \le u(k) \le c^{\text{BE}} \quad (9)$$

$$0 \le y^{\text{BE}}(k) \le r_{\text{max}} + c^{\text{BE}} \quad (10)$$

Equation (9) shows that the submission size does not exceed the approximated completion rate of the jobs $c^{\text{BE}}$. This constraint is not strict and is intended to be relaxed. Equation (10) shows that the number of running and waiting jobs at each iteration does not exceed the platform's capacity, plus a safe number of queued jobs equal to the resources estimated to be freed at each iteration.

2) Disturbance Model (HP Jobs): The system is subject to disturbances due to the arrival and execution of HP jobs. We use RJMS sensor to detect the arrival of HP jobs over a time horizon $\mathcal{H}$. It provides information about the number of resources currently occupied and expected to be occupied in the future as a time vector:

$$d(k, \mathcal{H}) = [d(k) \ d(k+1) \ \dots \ d(k+\mathcal{H})]^{\top} \in \mathbb{R}^{\mathcal{H}+1} \quad (11)$$

This sensor can be used to collect data on the platform jobs, their arrival, duration, and size. The horizon $\mathcal{H}$ length is chosen so that the controller reacts fast enough to the disturbances. It is chosen as $\mathcal{H} = \frac{p^{\text{BE}}}{\Delta t}$ and each HP job is characterized by a number of resources $q_j^{\text{HP}}$, and execution time $p_j^{\text{HP}}$. The evolution of the number of resources occupied by HP jobs has the following dynamics and can be described as:

$$y^{\text{HP}}(k+1) = y^{\text{HP}}(k) + d(k) - c^{\text{HP}}(q_j^{\text{HP}}, p_j^{\text{HP}}, k) \quad (12)$$

where $y^{\text{HP}}(k)$ represents the number of resources already occupied by HP jobs at iteration $k$, $d(k)$ represents the number of resources requested by newly submitted HP jobs at iteration $k$ that depends on the availability of resources (expressed in terms of the number of resources they require), and $c(q_j^{\text{HP}}, p_j^{\text{HP}})$, $k$ represents the number of resources freed at iteration $k$ due to the completion of HP jobs.

The completion rate, represented by $c^{\text{HP}}(k)$, depends on HP jobs parameters, their size $q_j^{\text{HP}}$ (i.e., the number of resources each job occupies) and their processing time $p_j^{\text{HP}}$. Since both $q_j^{\text{HP}}$ and $p_j^{\text{HP}}$ are subject to stochastic variations, the number of resources freed per iteration is inherently random. Consequently, the evolution of $y^{\text{HP}}$ over time is influenced by both the stochastic nature of incoming job submissions and the variability in job completion dynamics. For the sake of simplicity, we model the system as a first order system:

$$y^{\text{HP}}(k+1) = \hat{A}y^{\text{HP}}(k) + \hat{B}d(k) \quad (13)$$

where $\hat{A} = A$ and $\hat{B} = B$ since BE jobs and HP jobs are both HPC jobs and allocated similarly by the RJMS. We have a constraint on the disturbance:

$$y^{\text{HP}}(k) + d(k) \le r_{\text{max}} \quad (\text{cluster size}) \quad (14)$$

where the scheduler cannot schedule more resources to HP jobs than the available capacity. This means that the number of running and arriving resources at time $k$ cannot exceed the cluster size (where one job corresponds to the number of resources it occupies, i.e., its size).

## V. CONTROL DESIGN

In this section, we introduce the control strategy used to regulate the submission of BE jobs on the HPC platform. The controller is based on a Stochastic Model Predictive Control (SMPC) framework presented in [34] which serves as the foundation for our approach for the direct path with a feed-forward compensation for the disturbance path. It accounts for uncertainty in job execution times and system variability. The main objective is to maximize the usage of idle resources while ensuring system constraints are satisfied with high probability. The control design is developed using the system dynamics identified earlier, incorporating both feedback regulation and probabilistic constraint handling.

### A. Direct Path: Stochastic Model Predictive Control

In the stable region, the system described in the previous section has the following properties: (i) it is a linear system subject to uncertainty and additive disturbance, (ii) it has
probabilistic constraints. The linear system is represented as follows:

$$y(k) = y^{\text{HP}}(k) + y^{\text{BE}}(k) \quad (15)$$

Here, $y^{\text{BE}}(k)$ represents the output signal, which includes the number of running and waiting BE jobs at each time step $k$ presented earlier in eq. (3), and $y^{\text{HP}}(k)$ is the additive disturbance output of eq. (13).

To account for the uncertainty introduced by $\varepsilon(k)$ in eq. (3), the output constraint is reformulated as a chance constraint:

$$\Pr(0 \le y^{\text{BE}}(k) \le r_{\text{max}} + c^{\text{BE}} \ge \beta) \quad (16)$$

Here, $\beta$ is a risk parameter that specifies the minimum acceptable probability with which the constraint should hold. This means the constraint is not required to be satisfied in every instance but must hold true at least $\beta$ percent of the time. A higher value of $\beta$ corresponds to a more conservative (lower-risk) constraint.

To implement the chance constraint in an optimization problem, it must be converted into a deterministic equivalent by tightening the original constraint. This yields:

$$y^{\text{HP}}(k) \le r_{\text{max}} + c^{\text{BE}} - \gamma(k) \quad (17)$$

$$\gamma(k) = \sqrt{2} \operatorname{erf}^{-1}(2\beta - 1) \cdot \sqrt{g \operatorname{Cov}_e(k) g^\top} \quad (18)$$

with $g$ the states constraints vector, and since we have one state which is the output $g = [1]$.

Equation (17) is an approximation of the chance constraint in eq. (16). In other words, the original state constraint is tightened by the margin $\gamma$, which depends on the risk parameter $\beta$ and the error covariance matrix $\operatorname{Cov}_e(k)$ derived in eq. (23). The term $\sqrt{g \operatorname{Cov}_e(k) g^\top}$ captures the uncertainty (i.e., the variance of the error). The expression $\sqrt{2} \operatorname{erf}^{-1}(2\beta-1)$ comes from the properties of the normal distribution and quantifies how strict the constraint should be based on the risk level. Here, $\operatorname{erf}^{-1}$ is the inverse error function of the standard normal cumulative distribution function (CDF) [35].

The system dynamics in eq. (15) can now be split into a deterministic $z(k)$ and a probabilistic part $e(k)$.

$$y(k) = z(k) + e(k) \quad (19)$$

We introduce a new decision variable $v(k)$, and accordingly, the input is modified as:

$$u(k) = -Ky(k) + v(k) \quad (20)$$

Splitting the output in this way results in the following system models [34]:

$$z(k + 1) = \Phi z(k) + Bv(k) \quad (21)$$

$$e(k + 1) = \Phi e(k) + Dw(k) \quad (22)$$

With $\Phi = A + BK$. Here, $K$ is a feedback gain matrix designed using a Linear Quadratic Regulator (LQR) approach. The term $Ky(k)$ acts to stabilize the deterministic part of the system, while $v(k)$ manages the remaining uncertainty. To

make accurate predictions in MPC, the error must be propagated forward, which yields the following error covariance recursion [34]:

$$\operatorname{Cov}_e(k + 1) = (A - BK) \operatorname{Cov}_e(k) (A - BK)^\top + D \operatorname{Cov}_\varepsilon D^\top \quad (23)$$

with initial condition $\operatorname{Cov}_e(0) = 0$.

Therefore, the error covariance matrix depends on the previous error propagated through the system, as well as the covariance of the uncertainty added at each step. It is important to distinguish between the uncertainty covariance matrix $\operatorname{Cov}_\varepsilon$, which is constant and models the external noise, and the error covariance matrix $\operatorname{Cov}_e(k)$, which evolves over time as it accounts for the effects of both control action and uncertainty.

The full SMPC optimal control problem is defined as follows:

$$\min_V \sum_{k=0}^{N-1} (y(k) - y_{\text{ref}})Q(y(k) - y_{\text{ref}})^\top + (v(k) - Ky(k))R(v(k) - Ky(k))^\top \quad (24a)$$

$$\text{s.t.} \quad y(k + 1) = Ay(k) + B(v(k) - Ky(k)) + D\varepsilon(k) + \tilde{B} \cdot d(k) \quad (24b)$$

$$|v(k) - Ky(k)| \le c^{\text{BE}} \quad (24c)$$

$$y(k) \le r_{\text{max}} + c^{\text{BE}} - \gamma(k) \quad (24d)$$

$$\gamma(k) = \sqrt{2} \operatorname{erf}^{-1}(2\beta - 1) \cdot \sqrt{g \operatorname{Cov}_e(k) g^\top} \quad (24e)$$

where $V = [v_0, \dots, v_{N-1}]$ is the sequence of decision variables replacing the original control inputs [34].

## B. Disturbance Path: Feed-forward Compensation

The system is subject to frequent and highly stochastic additive disturbances—the arrival of HP jobs—which terminate BE jobs and reduce resources availability.

To improve the robustness and responsiveness of the control strategy, we introduce a feed-forward compensation mechanism. We use both the model of the BE jobs (system) and the HP jobs (disturbance) model presented in section IV to formulate the feed-forward control action:

$$u^{\text{FF}}(k) = -\frac{\dot{b}}{b} [d(k + \mathcal{H}) - a \cdot d(k + \mathcal{H} + 1)] + \dot{a} \cdot u^{\text{FF}}(k - 1) \quad (25)$$

Where $a, b, \dot{a}, \dot{b}$ are the parameters of the system and disturbance models respectively, and we consider then to be equal since BE jobs are HPC jobs and their behavior do not differ from those of HP jobs. $\mathcal{H}$ is the prediction horizon, $d$ is the forecast disturbance. The feed-forward control term is modeled as an additive component to the control input, based on the predicted disturbance signal, representing the expected number of HP jobs arriving at time. The control input becomes:

$$u(k) = u^{\text{FB}}(k) + u^{\text{FF}}(k) \quad (26)$$

where $u^{\text{FB}}(k)$ is the control computed from the SMPC as described in eq. (20). This proactive mechanism improves the SMPC controller's ability to meet probabilistic constraints and reduces the likelihood of terminating ongoing BE jobs.
## VI. EVALUATION

In this section, we evaluate the effectiveness of the proposed BE model presented in section IV, as well as the performance of the control strategy of section V in managing BE job submission under realistic HPC workload conditions. We use the implementation provided in [34] to solve the optimization problem. We divide the evaluation into two parts: model accuracy and control performance.

### A. Model Accuracy

Figure 3a shows the input signal $u$, representing the number of BE job submissions per iteration, with step increases of 5, 10, and 20 jobs. Figure 3c shows the total number of running and waiting BE jobs. Figures 3b and 3d show the output values separately for clearer insight into their individual behavior.

<figure><img src="image_3.png" /><figcaption>Fig. 3: Comparison between the real system behavior and the BE model prediction. Plot (a) shows the input signal $u$, representing BE job submissions with increasing step profiles. Plot (c) displays the output of the system which is equal to the total number of BE jobs in the system (sum of running and waiting). The plots (b) and (d) separate these two variables to highlight their individual dynamics.</figcaption></figure>

We observe that the system remains stable when the submission rate is below the approximated job completion rate $c^{BE}$: the number of waiting jobs stays at zero, and the number of running jobs increases linearly with the input. When the input exceeds $c^{BE}$, the number of running jobs reaches the maximum available resources $r_{max}$, with noise. At the same time, the number of waiting jobs continues to grow until it reaches the queue threshold, at which point further submissions are rejected and the queue begins to drain as jobs complete.

To validate the adequacy of the model presented in section IV and shown in fig. 3b of the output, we compare its predictions against observed system behavior. The results show that the model accurately predicts the evolution of BE resource occupation, achieving an average Root Mean Square Error

(RMSE) of 7.74 jobs. This corresponds to a relative error of only 0.13% with respect to the total number of submitted jobs. The variations between the model and the real data are due to the inaccuracies in the noise model and the extreme fluctuations in the running jobs sensor data.

### B. Control results

In the following, we study the performance of the proposed Stochastic Model Predictive Control (SMPC) under realistic HPC conditions, i.e, disturbance workloads and noise in the execution time of BE workloads. The goal is to validate how well the controller meets the overall objectives: maximizing resource utilization, minimizing the number of killed Best-Effort jobs, limiting the effects on the performance of HP jobs, and ensuring that system constraints are satisfied despite the presence of uncertainty and external disturbances. We present results from simulated workloads, comparing the SMPC-based policy with baseline approaches: PI control from previous works [33], and classic MPC, in terms of resource occupation, and responsiveness to high-priority job arrivals.

For the SMPC, we set the gains in eq. (24) to $Q = 10$ and $R = 1$, prioritizing accurate tracking of the desired system state over minimizing control effort. This choice reflects the fact that the system can tolerate more frequent or aggressive adjustments in job allocation if it results in better tracking performance. The risk parameter for the chance constraint in eq. (17) was set to $\beta = 0.8$, allowing for a 20% probability of constraint violation. We experimentally found that lower risk levels led to overly aggressive control actions, resulting in increased queue lengths and higher rates of early termination of BE jobs. The chosen value provided a favorable trade-off between constraint satisfaction and scheduling efficiency.

<figure><img src="image_4.png" /><figcaption>Fig. 4: Evolution of Best-Effort job occupancy and queue behavior under different control strategies: PI, MPC, and SMPC. For a fair comparison, the same feedforward component used in SMPC was also added to the PI and MPC controllers.</figcaption></figure>

Figure 4 provides a visual comparison of how the three controllers manage job submissions over time. The PI controller exhibits significant queue growth and eventual job early
termination since it only reacts to disturbances and does not anticipate. The classic MPC performs more consistently overall, but occasionally allocates more jobs than necessary. This happens because it does not account for system uncertainty, leading to a persistently higher number of jobs in the queue than required. The SMPC, on the other hand, demonstrates smoother adaptation with minimal waiting jobs and more consistent resource occupancy, leaving a small margin of safety on the running jobs given the uncertainty in the execution times and less disrupting the performance of the HP jobs, confirming its robustness to uncertainty and responsiveness to HP job arrivals.

Table I summarizes the performance of each control strategy. The SMPC controller maintains low idle resource usage (measured in core-hours) while avoiding any job terminations, as it accounts for potential extensions in job execution times. Additionally, the feedforward mechanism reinforces caution by limiting excessive job submissions, preventing the submission of more jobs than necessary. On average, the algorithm takes 0.25 s to find a solution, with a maximum of 0.50 s: both values are well below the sampling period.

The MPC controller achieves the lowest idle resource usage because it does not account for system stochasticity. As a result, it is less conservative when filling the waiting queue, which leads to a higher number of job terminations compared to the SMPC. In contrast, the PI controller performs poorly across all metrics, highlighting the benefits of using predictive and uncertainty-aware strategies for managing HPC workloads.

<table><caption>TABLE I: Performance comparison of control strategies.</caption><thead><tr><th rowspan="2">Controller</th><th colspan="2">Idle resources</th><th colspan="2">Terminated jobs</th></tr><tr><th>core-hour</th><th>%</th><th>core-hour</th><th>%</th></tr></thead><tbody><tr><td>SMPC</td><td>1560.95</td><td>1.86</td><td>0.00</td><td>0.00</td></tr><tr><td>MPC</td><td>1024.04</td><td>1.22</td><td>5.06</td><td>0.08</td></tr><tr><td>PI</td><td>3912.41</td><td>4.66</td><td>95.98</td><td>1.69</td></tr></tbody></table>

## VII. CONCLUSION

In this paper, we proposed a Stochastic Model Predictive Control (SMPC) to regulate the submission of Best-Effort jobs in high-performance computing (HPC) environments under uncertainty. By combining predictive control with probabilistic constraint handling and feedforward compensation, the approach enables efficient use of idle resources while minimizing the risk of job terminations and disruptions to high-priority workloads. Simulation results demonstrated that the SMPC controller outperforms traditional control strategies such as PI and deterministic MPC in terms of resource utilization, job preservation, and responsiveness to workload changes. This work highlights the potential of control-theoretic methods—particularly stochastic optimization—in improving the adaptability and efficiency of HPC systems.

## VIII. LIMITATIONS AND FUTURE WORK

While the proposed SMPC approach demonstrates strong performance, several limitations remain, each of which points to a direction for future work:

* The disturbance and system models do not account for interactions between high-priority (HP) and best-effort (BE) jobs (e.g., early terminated jobs re-entering the queue). Future work will develop a multi-input, multi-output (MIMO) state-space representation that captures such interactions.

* The current plant model assumes homogeneous BE jobs, which limits realism of the workloads. Future work will incorporate heterogeneous job types with varying execution profiles and resource requirements, including varying I/O profiles.

* The disturbance rejection mechanism assumes prior knowledge of future HP job arrivals. This assumption holds only when users schedule their jobs in advance. It also assumes that the start time and execution time of HP jobs are known in advance. While this simplifies the model, it may not accurately reflect real-world variability and should be accounted for in the disturbance model.

* File server usage and I/O-intensive behavior are not currently modeled. Extending the system model to capture these effects.

* The control strategy has been evaluated only through simulation. An important next step is to validate the approach using real HPC job traces and deploy it on an operational system.

* The scalability of the current approach to larger, more complex HPC platforms has not been evaluated. Future work will investigate performance under more diverse scheduling and resource management policies.

## REFERENCES

[1] T. L. Sterling et al., *High Performance Computing: Modern Systems and Practices*, 1st ed. 2017. DOI: 10.1016/C2013-0-09704-6.

[2] E. Strohmaier et al. “TOP500 list,” Accessed: 2025-05-16. [Online]. Available: https://www.top500.org/lists/.

[3] T. Tsoneva and J. Affleck. “Decoding Data Centers: Opportunities, risks and investment strategies,” Accessed: 2025-05-19. [Online]. Available: https://www.cbreim.com/insights/articles/decoding-data-centers.

[4] S. Choochotkaew et al. “Idle Power Matters: Kepler Metrics for Public Cloud Energy Efficiency,” Accessed: 2025-05-14. [Online]. Available: https://tag-env-sustainability.cncf.io/blog/2024-06-idle-power-matters-kepler-metrics-for-public-cloud-energy-efficiency/.

[5] R. J. Wysocki, *The Linux kernel user's and administrator's guide*, version 6.15.0-rc6, ch. CPU Idle Time Management. Accessed: 2025-05-15. [Online]. Available: https://docs.kernel.org/admin-guide/pm/cpuidle.html.

[6] Y. Georgiou et al., “Evaluations of the Lightweight Grid CIGRI upon the Grid5000 Platform,” in *eScience*, 2007, pp. 279–286. DOI: 10.1109/E-SCIENCE.2007.32.

[7] B. Bzeznik and O. Richard, *CiGri*, URL: http://cigri.imag.fr/, vcs: https://github.com/oar-team/cigri.git, SWHID: (swh:1:dir:f8b6df45300534e9807addc7ec125cd72b92c139;origin=github.com/oar-team/cigri).
[8] “GRICAD,” Accessed: 2025-05-14. [Online]. Available: https://gricad.univ-grenoble-alpes.fr/.

[9] N. Capit et al., “A batch scheduler with high level components,” in *CCGRID*, 2005, pp. 776–783. doi: 10.1109/CCGRID.2005.1558641.

[10] E. Stahl et al., “Towards a control-theory approach for minimizing unused grid resources,” in *AI-Science@HPDC*, 2018, 4:1–4:8. doi: 10.1145/3217197.3217201.

[11] Q. Guilloteau et al., “Model-Free Control for Resource Harvesting in Computing Grids,” in *CCTA*, 2022, pp. 384–390. doi: 10.1109/CCTA49430.2022.9966035.

[12] A. G. Yabo et al., “A control-theory approach for cluster autonomic management: Maximizing usage while avoiding overload,” in *CCTA*, 2019, pp. 189–195. doi: 10.1109/CCTA.2019.8920473.

[13] R. Pagano et al., “Making Control in High Performance Computing for Overload Avoidance Adaptive in Time and Job Size,” in *CCTA*, 2024, pp. 753–760. doi: 10.109/CCTA60707.2024.10666583.

[14] É. Rutten et al., “Feedback Control as MAPE-K Loop in Autonomic Computing,” in *Software Engineering for Self-Adaptive Systems*, ser. LNCS, vol. 9640, 2013, pp. 349–373. doi: 10.1007/978-3-319-74183-3_12.

[15] T. Abdelzaher et al., “Introduction to Control Theory And Its Application to Computing Systems,” in *Performance Modeling and Engineering*, 1st ed. 2008, pp. 185–215. doi: 10.1007/978-0-387-79361-0_7.

[16] D. Arcelli et al., “Control Theory for Model-based Performance-driven Software Adaptation,” in *QoS*, 2015, pp. 11–20. doi: 10.1145/2737182.2737187.

[17] R. D. Caldas et al., “A Hybrid Approach Combining Control Theory and AI for Engineering Self-Adaptive Systems,” in *SEAMS@ICSE*, 2020, pp. 9–19. doi: 10.1145/3387939.3391595.

[18] R. D. Caldas et al., “Towards Mapping Control Theory and Software Engineering Properties using Specification Patterns,” in *ACSOS-C*, 2021, pp. 281–286. doi: 10.1109/ACSOS-C52956.2021.00067.

[19] A. Ullah et al., “A control theoretical view of cloud elasticity: Taxonomy, survey and challenges,” *Clust. Comput.*, vol. 21, no. 4, pp. 1735–1764, 2018. doi: 10.1007/S10586-018-2807-6.

[20] D. Grimaldi et al., “A Feedback-Control Approach for Resource Management in Public Clouds,” in *GLOBECOM*, 2015, pp. 1–7. doi: 10.1109/GLOCOM.2014.74.17016.

[21] S. Wijaya et al., “Cloud-based control systems: A systematic literature review,” *Int. J. Reconfig. Embed. Syst.*, vol. 12, no. 1, pp. 135–148, 2023. doi: 10.11591/ijres.v12.i1.pp135-148.

[22] S. Park and M. A. Humphrey, “Predictable High-Performance Computing Using Feedback Control and Admission Control,” *IEEE Trans. Parallel Distributed Syst.*, vol. 22, no. 3, pp. 396–411, 2011. doi: 10.1109/TPDS.2010.100.

[23] D. Huber et al., “Design Principles of Dynamic Resource Management for High-Performance Parallel Programming Models,” 2024. arXiv: 2403.17107v1 [cs.DC].

[24] B. Przybylski et al., “Using Unused: Non-Invasive Dynamic FaaS Infrastructure with HPC-Whisk,” in *SC*, 2022, 40:1–40:15. doi: 10.1109/SC41404.2022.00045.

[25] M. Mercier et al., “Big Data and HPC collocation: Using HPC idle resources for Big Data Analytics,” in *IEEE BigData*, 2017, pp. 347–352. doi: 10.1109/BigData.2017.8257944.

[26] A. Mesbah, “Stochastic Model Predictive Control: An Overview and Perspectives for Future Research,” *IEEE Control Systems Magazine*, vol. 36, no. 6, pp. 30–44, 2016. doi: 10.1109/MCS.2016.2602087.

[27] Y. Zhu et al., “Energy Optimal Dispatch of the Data Center Microgrid Based on Stochastic Model Predictive Control,” *Front. Energy Res.*, vol. 10, 2022. doi: 10.3389/fenrg.2022.863292.

[28] A. D. Bonzanini and A. Mesbah, “Learning-based Stochastic Model Predictive Control with State-Dependent Uncertainty,” in *PMLR*, vol. 120, 2020, pp. 571–580. Accessed: 2025-05-19. [Online]. Available: http://proceedings.mlr.press/v120/bonzanini20a.html.

[29] H. Chen and Z. Zhang, “Stochastic Model Predictive Control of Autonomous Systems with Non-Gaussian Correlated Uncertainty,” 2019. arXiv: 1910.02994v1 [eess.SY].

[30] C. Shang and F. You, “A data-driven robust optimization approach to scenario-based stochastic model predictive control,” *Journal of Process Control*, vol. 75, pp. 24–39, 2019. doi: 10.1016/j.jprocont.2018.12.013.

[31] D. Bernardini and A. Bemporad, “Scenario-based model predictive control of stochastic constrained linear systems,” in *CDC*, 2009, pp. 6333–6338. doi: 10.1109/CDC.2009.5399917.

[32] Q. Guilloteau et al., “Étude des applications Bag-of-Tasks du méso-centre Gricad,” in *COMPAS*, 2022. [Online]. Available: https://hal.science/hal-03702246.

[33] Q. Guilloteau, “Control-based runtime management of HPC systems with support for reproducible experiments,” Ph.D. dissertation, Univ. Grenoble Alpes, France, 2023. [Online]. Available: https://tel.archives-ouvertes.fr/tel-04389290.

[34] T. Brüdigam, “(Stochastic) Model Predictive Control – a Simulation Example,” 2023. arXiv: 2101.12020v6 [eess.SY].

[35] O. M. Eidous and M. Al-Rawash, “Approximations for Standard Normal Distribution Function and Its Invertible,” 2022. arXiv: 2206.12601v1 [stat.CO].