Skip to content
Conference Open access

Estimating Execution Progress of Black-Box Tasks with Resource-Consumption Models

Jul 2026 · IEEE International Conference on Cloud Computing · pp. 235-245 · 0 citations · 22 references

TL;DR

This work presents a novel approach that, given a generic resource-consumption model, estimates the progress of an ongoing execution in the form of a probability distribution which supports uncertainty quantification, and performs estimation via Markov-chain Monte-Carlo sampling around a maximum a posteriori estimate.

Abstract

In cloud environments, recurring workloads such as data processing jobs, CI/CD tasks and machine learning pipelines are typically executed as opaque black-box programs. Their internal progress is not directly observable, yet their resource-consumption patterns often exhibit structural similarity across runs despite variations in input data and hardware. Accurately estimating the progress of such running tasks can bring major benefits to scheduling and resource optimization. Using resource-consumption models of such tasks, derived from previous task execution monitoring, to accurately estimate a tasks cumulative progress allows detailed and accurate proactive resource steering, planning and scheduling. We present a novel approach that, given a generic resource-consumption model, estimates, based on current resource monitoring data, the progress of an ongoing execution in the form of a probability distribution which supports uncertainty quantification. The approach accounts for deviations from the model caused by varying system performance profiles, input sizes and parameters. It performs estimation via Markov-chain Monte-Carlo sampling around a maximum a posteriori estimate. Synthetic evaluations show that the approach reliably estimates task progress with an error of approximately 0.09 when suitable priors were selected. Real-world demonstrations show that the approach remains effective, and that performance degrades only slightly when the method is applied to real data. The degree of robustness to poor prior selection has also been thoroughly explored.

Read PDF

Similar papers

Conference 2026

Uncertainty-Aware Resource Allocation for Multi-Path Programs with In-Kernel Predictions

Experimental results on SPEC CPU benchmarks show that MPORA delivers accurate predictions under unseen inputs and distribution shifts with low overhead, while improving schedulability and response times over existing methods.

Abby Eisenklam, G. CarlosA.Montenegro, Xian Wang et al. · 0 citations
#edge computing Preprint Aug 2026

PRISM: Predictive Runtime In-place Scaling and Model Selection for Edge Microservices

PRISM, a prediction-guided runtime framework that jointly selects model variants and CPU allocations for containerized edge microservices, and adapts each pipeline stage in place and minimizes predicted CPU-package energy under deadline, resource, and offline model-level Quality of Result constraints is presented.

Uwe Gropengießer, Thomas Reuter, Dominik Schön et al. · 0 citations
Preprint Aug 2026

PeakBench: Benchmarking Resource-Aware Tool Invocation in LLM Agents

PeakBench is a benchmark of executable multi-tool workflows with execution-grounded dependency annotations and measured resource profiles that shows that strong logical planning does not reliably translate into safe or efficient execution under resource constraints, and exposes resource information to reduce avoidable overflows and improve resource utilization.

Zhi-Kai Chen, Xu-Xiang Zhong, Song-Yan Li et al. · 0 citations
Open access Aug 2026

Predicting Runtime in Spark‐Like Systems With Allocation‐Aware Deterministic Models

Apache Spark is widely used for distributed data processing, but accurately predicting application execution time remains challenging because performance depends on application structure, resource configuration, and executor‐allocation behavior. This article presents two deterministic, graph‐based simulation models for predicting the execution time of Spark applications under static and dynamic executor allocation. The first model, the Static Allocation Model (SAM), represents an application as a monolithic directed acyclic graph (DAG) of stages and simulates execution using Spark's scheduling behavior under a fixed number of executor cores. To capture more realistic execution environments, this framework is extended to a Dynamic Allocation Model (DAM), which accounts for runtime changes in executor resources using backlog‐time and idle‐time thresholds. DAM dynamically adjusts executor allocation during execution and integrates these changes within the deterministic scheduling framework. Validation of SAM on three TPC‐DS benchmark queries—Query‐64, Query‐26, and Query‐52—yielded prediction errors of 2.9%, 4.3%, and 0.4%, respectively, with a mean absolute error of 2.5%. Experimental evaluation of DAM on TPC‐DS Query‐52 and the SparkBench K‐Means workload yielded prediction errors of 5% and 4.7%, respectively. To the best of our knowledge, this work presents the first deterministic approach for modeling Spark application execution time under dynamic executor allocation. The proposed models are lightweight, interpretable, and require minimal input data, offering a practical alternative for performance prediction and resource optimization in distributed data‐processing systems.

Hina Tariq, O. Das · 0 citations
Book Open access Jul 2026

Analyzing HPC Job Wait Times under Resource Scaling Using Historical Workload Data

This work presents a data-driven framework that leverages historical job traces to estimate the impact of resource modifications on queue performance, and introduces the Weighted Wait-Time Score (WWS), a bounded metric that captures both typical and tail wait-time behavior.

Bipin Gaikwad, Shraddha Singh, M. Joshi et al. · 0 citations
Preprint Sep 2026

Latency-Aware Orchestration for Multi-Agent LLM Workflows on Heterogeneous GPUs

Concurrent multi-agent workflows expose future dependencies and serving-state requirements while running on heterogeneous GPU pools with time-varying load, model residency, and resource availability. The logical workflow defines the required computation, whereas its physical scheduling units, model-lifecycle actions, resource ordering, and placement must be selected according to the observed pool state. We present a prediction-guided runtime that uses workflow forecasts to construct and optimize a physical execution graph. Predictor estimates device-specific activation latency, peak memory, and model-loading cost, then propagates these predictions through workflow dependencies to forecast activation readiness and future model demand. Constructor builds semantics-preserving fusion and model-lifecycle alternatives, while Scheduler jointly optimizes their selection, placement, and execution order based on the live pool state. Across a workload spanning three workflow scenarios on a heterogeneous GPU pool, our system reduces end-to-end makespan and overall p95 completion latency under burst arrivals by up to 36.8% and 25.9%, respectively, over state-of-the-art workflow schedulers. It also saves up to 24.63 GPU-s per completed session.

Jing-Hao Wang, Yi-Feng Zhang, Xiao Zhou et al. · 0 citations

We use cookies to run the site and, with your consent, for analytics and to show ads. See our Cookie Policy.