The results show that soft SLO limits reduce corrective rescheduling actions by 49% compared to hard-limit approaches while maintaining acceptable performance guarantees, and resource-aware scheduling decreases node-level congestion and further mitigates SLO violations, demonstrating the effectiveness of incorporating application-level flexibility and hardware-level insights into scheduling and rescheduling decisions.
Abstract
Workload scheduling in cloud environments often relies on simplistic assumptions about application resource needs and hardware utilization. Overlooking application-level performance objectives and hardware resource contention that leads to inefficient resource usage and degraded performance. This paper addresses two key limitations of current approaches. First, unnecessarily strict enforcement of service level objectives (SLOs) often leads to resource underutilization and poor energy efficiency. Second, lack of congestion awareness in shared resources such as last-level cache (LLC) and memory bandwidth. In this paper, we propose two complementary strategies to address these limitations: (i) integrating soft SLO limits that allow controlled overcommitment and tolerate minor, transient violations to improve cluster efficiency, and (ii) introducing resource-aware scheduling and rescheduling based on real-time congestion insights for shared resources such as last-level cache (LLC) and memory bandwidth. Our results show that soft SLO limits reduce corrective rescheduling actions by 49% compared to hard-limit approaches while maintaining acceptable performance guarantees. Additionally, resource-aware scheduling decreases node-level congestion by 8% and further mitigates SLO violations, demonstrating the effectiveness of incorporating application-level flexibility and hardware-level insights into scheduling and rescheduling decisions.
Compute and memory resources in cloud environments are strictly managed and isolated by the control plane; in contrast, network resources lack equivalent management and isolation mechanisms. This best-effort treatment of networking leads to significant challenges for modern AI workloads, which have diverse and bandwidth-intensive communication patterns. Without fine-grained network resource control, these workloads suffer from interference, unpredictable throughput, and suboptimal cluster utilization. To address these issues, this paper demonstrates how network bandwidth can be elevated to a first-class, schedulable, and enforceable resource within Kubernetes, the de facto standard for cloud-native orchestration. We introduce a new scheduling capability that models network interfaces as allocatable resources and regulates bandwidth sharing through the Dynamic Resource Allocation (DRA) framework, with enforcement implemented using the Hierarchical Token Bucket (HTB) mechanism. We evaluate the system using multitenant AI workloads derived from real-world communication characteristics with a simulation-based approach and validate the proposed enforcement strategy in a real cluster. Results show that the proposed two-level bandwidth allocation improves tenant performance predictability and satisfaction while maintaining packed cluster utilization.
Function-as-a-Service offers cost efficiency but often suffers from resource underutilization. This underutilization stems from the instance-level resource provisioning pattern, an issue that existing optimizations have failed to resolve fundamentally. The core problem is that static coarse-grained instance-level resource allocation cannot match the millisecond-level burstiness of dynamic requests. Consequently, it is difficult for current systems to achieve high resource utilization while maintaining high quality of service (QoS) guarantees. To address the problem, this paper advocates a shift to request-level resource provisioning, which redefines the individual request as the atomic unit for scheduling and resource management. We implement this approach in RRP, a scalable FaaS platform that enables efficient per-request resource allocation and release. RRP unifies instance placement and request routing with low-overhead, millisecond-level global visibility. Our evaluation shows that RRP significantly outperforms state-of-the-art instance-level platforms and algorithms. By matching resources to each request’s needs and isolating them from contention, RRP achieves low latency and high utilization. Specifically, on real-world Azure traces, RRP achieves speedups of 1.33 × –30.15 × for average end-to-end latency and 1.37 × –61.46 × for P99 latency, and raises CPU utilization from 44.80%–56.32% to 72.49% under bursty loads.
Runfu Li, Zishu Yu, Yifan Wang et al.· IEEE International Symposium...· 0 citations
TADOF is a dynamic optimization framework that jointly performs energy-aware elastic scaling and task migration under drift-aware periodic modeling and burst detection and observed about 18–34% lower energy and 15–28% lower migration cost than threshold and A2C/TD3 baselines while preserving QoS.
Juan Guo, Yanqun Zuo, Zhixian Chang· Cluster Computing· 0 citations
The lack of determinism restricts the integration of safety-critical applications into Edge–Fog–Cloud (EFC) architectures. Existing EFC schedulers are typically designed for dynamic, best-effort operation based on unmanaged resource allocation and elastic virtualization. This paradigm introduces unbounded queueing, resource contention, and timing jitter, making standard schedulers unsuitable for hard-deadline workloads. Moreover, most approaches focus on computational placement, while communication is abstracted or treated as a secondary cost term. As a result, bounded-latency routing and deterministic task execution are rarely co-optimized under a unified timing model. This paper addresses these gaps by utilizing a managed Time-Triggered Edge–Fog–Cloud (TTEFC) architecture that supports safety-critical workloads, orchestrates IEEE Time-Sensitive Networking (TSN) for local intra-domain communication, and uses IETF Deterministic Networking (DetNet) for routed inter-domain paths. On this infrastructure, a hierarchical genetic algorithm (HGA) is proposed to jointly schedule partition-to-execution-location allocation, partition execution order, inter-partition route selection, and negotiated per-partition time budgets that act as temporal boundaries for parallel partition-level optimizers. An adaptive slack reallocation operator redistributes unused temporal slack from over-satisfied partitions to budget-violating partitions, improving feasibility convergence. Experiments on synthetic DAG workloads with 100–500 tasks compare the proposed HGA against HEFT and round-robin baselines. These baselines are included as scoped external references to contextualize the end-to-end scheduling performance of the proposed method. Ablation results show that slack reallocation improves partition-budget feasibility, reaches feasible budget assignments earlier, and produces tighter budget–makespan alignment than feedback-free and static-budget variants. An automotive-characteristic DAG case study further evaluates the method on an application-oriented workload under the same timing and communication assumptions.
Omar Hekal, Josepaul Paulachan, Daniel Onwuchekwa et al.· Future Internet· 0 citations
Efficient management of shared cache resources is a key challenge in multicore real-time systems. Mechanisms such as Intel’s Cache Allocation Technology (CAT) enable software control over last-level cache (LLC) partitions, providing opportunities to reduce interference and tighten worst-case execution time (WCET) bounds. Existing approaches typically rely on static cache allocation, which can lead to over-provisioning and inefficient cache usage. This paper introduces a job-level dynamic cache allocation strategy for multicore systems in which critical real-time tasks execute on a dedicated core while sharing the LLC with best-effort workloads executing on the remaining cores. We formulate the allocation problem as a constraint-based optimization model that simultaneously enforces schedulability constraints, cache capacity limits, and preemption-induced concurrency. By allocating and releasing cache partitions at job boundaries, our approach adapts to temporal variations in job activity, minimizing the cache dedicated to critical tasks while preserving their schedulability. Through evaluation on synthetic task sets, we show that job-level dynamic allocation improves schedulability and systematically increases the cache available to non-critical tasks compared to task-level static or dynamic strategies. Moreover, it often requires fewer allocation operations, indicating that increased flexibility does not entail higher runtime overhead. These results demonstrate that job-level cache allocation is a promising direction for efficient and predictable resource management in multicore real-time systems.
Micha¨el Lauer, Aléxis Génèrès, J. Fabre· ACM Transactions on Embedded...· 0 citations
This paper presents a novel hybrid segmented policy that reduces capacity requirements while keeping processing costs low and shows that dynamically adjusting the segment ratio in segmented policies based on historical workload patterns enhances efficiency.