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.
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
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
While traditional cache policy evaluations fix capacity - often at 0.1% of the dataset - and measure the resulting hit rate, practical edge-cloud deployments require balancing both storage and computational overhead as billed resources. Consequently, system operators frequently focus on a different objective: determining the minimum cache size needed to satisfy a specific Service-Level Objective (SLO) hit-rate. This paper explores this SLO-centric paradigm by analyzing the minimum capacity and execution time each policy requires to hit a defined target. Additionally, we show that dynamically adjusting the segment ratio in segmented policies based on historical workload patterns enhances efficiency. Through evaluations across real-world and synthetic traces, we present a novel hybrid segmented policy that reduces capacity requirements while keeping processing costs low.