An Elastic Job Scheduler for HPC Applications on the Cloud

TL;DR

This work tackles elastic execution of HPC workloads in cloud environments by extending the Kubernetes MPI operator to run Charm++ applications and implementing a priority-based elastic scheduler that dynamically resizes running jobs. By leveraging Charm++ migratable objects and a Kubernetes-based operator, the system achieves rapid rescaling with low overhead, guided by a configurable $T_{rescale\_gap}$ and min/max replica bounds. The authors provide both simulative and real-cluster evaluations, showing that the elastic scheduler outperforms rigid and moldable strategies in cluster utilization and in mean response/completion times, while keeping rescaling overhead manageable. The results highlight a practical path toward high-utilization, low-latency HPC on the cloud, with artifacts including an elastic Charm++ operator (A1) and a scheduling simulator (A2) to enable reproducibility and extension.

Abstract

The last few years have seen an increase in adoption of the cloud for running HPC applications. The pay-as-you-go cost model of these cloud resources has necessitated the development of specialized programming models and schedulers for HPC jobs for efficient utilization of cloud resources. A key aspect of efficient utilization is the ability to rescale applications on the fly to maximize the utilization of cloud resources. Most commonly used parallel programming models like MPI have traditionally not supported autoscaling either in a cloud environment or on supercomputers. While more recent work has been done to implement this functionality in MPI, it is still nascent and requires additional programmer effort. Charm++ is a parallel programming model that natively supports dynamic rescaling through its migratable objects paradigm. In this paper, we present a Kubernetes operator to run Charm++ applications on a Kubernetes cluster. We then present a priority-based elastic job scheduler that can dynamically rescale jobs based on the state of a Kubernetes cluster to maximize cluster utilization while minimizing response time for high-priority jobs. We show that our elastic scheduler, with the ability to rescale HPC jobs with minimal overhead, demonstrates significant performance improvements over traditional static schedulers.

Figures (9)

• Figure 1: Shrink/Expand in Charm++
• Figure 2: Pseudocode for priority-based scheduling algorithm when a new job is submitted
• Figure 3: Pseudocode for priority-based scheduling algorithm when a job completes
• Figure 4: Scaling performance of Charm++ on Kubernetes
• Figure 5: Contribution of different stages of rescaling to the total rescaling overhead