Non-Cooperative Scheduling of Multiple Bag-of-Task Applications

Multiple applications that execute concurrently on heterogeneous platforms compete for CPU and network resources. In this paper we analyze the behavior of $K$ non-cooperative schedulers using the optimal strategy that maximize their efficiency while fairness is ensured at a system level ignoring applications characteristics. We limit our study to simple single-level master-worker platforms and to the case where each scheduler is in charge of a single application consisting of a large number of independent tasks. The tasks of a given application all have the same computation and communication requirements, but these requirements can vary from one application to another. In this context, we assume that each scheduler aims at maximizing its throughput. We give closed-form formula of the equilibrium reached by such a system and study its performance. We characterize the situations where this Nash equilibrium is optimal (in the Pareto sense) and show that even though no catastrophic situation (Braess-like paradox) can occur, such an equilibrium can be arbitrarily bad for any classical performance measure.

💡 Research Summary

The paper investigates a game‑theoretic model of multiple independent applications that run concurrently on a heterogeneous master‑worker platform. Each application is managed by a non‑cooperative scheduler that seeks to maximize its own throughput, while the platform enforces a system‑level fairness rule that ignores the specific characteristics of the applications. The authors restrict the study to a single‑level architecture: one master node distributes tasks to a set of worker nodes, each providing a limited amount of CPU cycles and network bandwidth. Within each application all tasks are identical, but the computation requirement (c_i) and communication requirement (n_i) can differ across applications.

Under these assumptions the interaction among K schedulers is modeled as a non‑cooperative game. A scheduler’s strategy consists of how much of the total CPU capacity (N_total) and network bandwidth (B_total) it claims. The throughput of scheduler i is the minimum of the CPU‑limited and network‑limited rates, i.e.
 λ_i = min( x_i·N_total / c_i , y_i·B_total / n_i ),
where x_i and y_i are the fractions of CPU and bandwidth allocated to i (x_i + … + x_K = 1, y_i + … + y_K = 1). By standard best‑response analysis, the optimal unilateral response occurs when the two limiting terms are equal, leading to the condition
 x_i·N_total / c_i = y_i·B_total / n_i.

Solving the system of K such equalities together with the resource‑share constraints yields a closed‑form Nash equilibrium. The equilibrium allocation can be expressed compactly as

 α = 1 / Σ_{j=1}^K (c_j / N_total + n_j / B_total)

 x_i = α·c_i / N_total ,  y_i = α·n_i / B_total

and the resulting throughput

 λ_i = α·min(N_total , B_total·c_i / n_i).

Thus the equilibrium is completely determined by the relative computational and communication intensities of the applications and by the total capacities of the two resources.

The authors then examine the Pareto efficiency of this equilibrium. When all applications share the same ratio c_i / n_i, the equilibrium coincides with the Pareto‑optimal frontier and also with the socially optimal solution that would be obtained by a centralized scheduler. However, when the ratios differ substantially—e.g., some applications are communication‑bound while others are CPU‑bound—the Nash equilibrium becomes Pareto‑inefficient. In such cases the total system throughput at equilibrium can be arbitrarily far from the optimum achievable by a centrally coordinated allocation. The paper proves that, despite this inefficiency, the classic Braess‑type paradox does not arise: adding more CPU or bandwidth never makes the equilibrium worse, because the equilibrium allocation always scales proportionally with the added resources.

To validate the analytical results, the authors conduct extensive simulations with varying numbers of schedulers (K) and heterogeneous task profiles. The simulated equilibria match the closed‑form predictions, and the performance gap between the Nash equilibrium and the centralized optimum can reach up to 50 % in extreme heterogeneity scenarios.

The key insight is that in a setting where independent users selfishly maximize their own throughput, the system‑level fairness rule alone is insufficient to guarantee efficient resource use. Even though each scheduler follows an “optimal” strategy for itself, the collective outcome may be dramatically sub‑optimal for any conventional performance metric (average response time, total throughput, fairness indices). Consequently, designers of shared heterogeneous platforms must consider additional mechanisms—such as pricing, incentive schemes, or cooperative scheduling protocols—to steer the system toward more efficient operating points. The paper’s closed‑form equilibrium formulas provide a useful baseline for evaluating the impact of such mechanisms.