Divide (CPU Load) and Conquer: Semi-Flexible Cloud Resource Allocation

TL;DR

This paper models semi-flexible cloud resource management, balancing application instances and load distribution to optimize machine usage and load balancing, with theoretical analysis and practical heuristics validated on Azure data.

Contribution

It introduces a new model capturing semi-flexibility in cloud resource management, analyzing its complexity and proposing exact algorithms and heuristics.

Findings

NP-hardness of the general problem.

Polynomial-time algorithms for special cases.

Flexibility can reduce machine requirements by a factor of up to 2.

Abstract

Cloud resource management is often modeled by two-dimensional bin packing with a set of items that correspond to tasks having fixed CPU and memory requirements. However, applications running in clouds are much more flexible: modern frameworks allow to (horizontally) scale a single application to dozens, even hundreds of instances; and then the load balancer can precisely divide the workload between them. We analyze a model that captures this (semi)-flexibility of cloud resource management. Each cloud application is characterized by its memory footprint and its momentary CPU load. Combining the scheduler and the load balancer, the resource manager decides how many instances of each application will be created and how the CPU load will be balanced between them. In contrast to the divisible load model, each instance of the application requires a certain amount of memory, independent of the number of instances. Thus, the resource manager effectively trades additional memory for more evenly balanced load. We study two objectives: the bin-packing-like minimization of the number of machines used; and the makespan-like minimization of the maximum load among all the machines. We prove NP-hardness of the general problems, but also propose polynomial-time exact algorithms for boundary special cases. Notably, we show that (semi)-flexibility may result in reducing the required number of machines by a tight factor of $2-\varepsilon$. For the general case, we propose heuristics that we validate by simulation on instances derived from the Azure trace.