Budget-Carrying Dataflow: Late-Binding Resource Sizing Without a Central Controller

Serverless workflows are chains of small cloud functions, such as decode a video, detect objects, then summarize. Over the past few years their design has split in two directions that no system has yet joined. One direction removes the central coordinator: each function fires as soon as its input data arrives, and data flows directly from one function to the next. The other direction keeps a central coordinator but makes it smarter. After each step it checks how much of the latency deadline is left and resizes the next function's CPU so that the deadline is met without over-provisioning. We propose to get the second benefit inside the first design. Each intermediate data message would carry a few bytes of "remaining time budget" plus a small slice of a developer-compiled lookup table. The node that receives the data can then size its own container locally, with no round trip to anyone.

The core idea is to decide early where a function runs and to decide late how much CPU it gets, and to separate the two decisions. That separation resolves an apparent contradiction in the literature. Late binding (deciding resources at the last moment) saves roughly a third of resources in one study. Early binding (committing work to a worker immediately) cuts tail slowdown by up to 85% in another. We argue the two results concern different decisions, and a decentralized dataflow engine can make each decision at its natural time.

Core Claim

DataFlower splits each container into a compute part and a communication part. It triggers functions reactively when data arrives and uses a host-side buffer, the Data Sink, to hold data that arrives before a container has finished starting. It reports P99 latency reductions of 5.7% to 35.4% and peak throughput gains of 1.03X to 3.8X over FaaSFlow, and it measures roughly 63 ms of scheduling lag per step in centralized controllers. Its resource sizes, however, are fixed when the workflow is deployed. Janus shows that this is wasteful. In its production data, half of all functions used under 10% of their allocated CPU. Janus fixes the waste with offline-profiled "hints tables" (compressed by up to 99.6%) that map remaining latency budget to the cheapest allocation for downstream functions. The tables are applied by a provider-side adapter in under 3 ms and improve resource efficiency by 29.9% to 34.7% over ORION and GrandSLAM. Janus's adaptation runs sequentially along a centralized control path.

Hermes appears to contradict Janus. On the heavy-tailed Azure Functions trace, binding work to workers early and sharing processors locally beats queueing in a central late-binding queue, with up to 85% less slowdown. We read Hermes's result as being about placement: central queues create head-of-line blocking, where one slow job holds up everything behind it. Janus's result is about sizing. Our claim is that if placement stays early and static, as in DataFlower's per-node engines, and sizing moves to the receiving node, driven by budget information carried with the data, then a decentralized system can match Janus-level resource savings while keeping DataFlower-level latency and Hermes-style freedom from central queues. We expect the advantage over a centralized Janus-style adapter to grow as the network round trip to that adapter grows. At near-zero round trip we expect parity, and we say so up front.

Research Program

The system has three layers, and they map onto the developer–provider "information barrier" that Janus identifies. At the top, a developer-side compiler profiles each function offline across CPU quotas, following Janus's method. It emits, for every edge of the workflow graph, a compressed hint slice: the part of the table relevant to the downstream function. In the middle, a per-node engine extends DataFlower's communication unit. It attaches a fixed-size header to each outgoing data message containing the workflow's absolute deadline, the request's start timestamp, and an identifier for the hint slice. At the bottom, the receiving node's local agent reads the header while the payload is still streaming into the Data Sink. It computes the remaining budget and adjusts the target container's CPU quota in place before the function starts.

The remaining budget for step $k$ is $b_k = D - (t_k - t_0)$, where $D$ is the end-to-end deadline, $t_0$ is the request start time, and $t_k$ is the arrival time of step $k$'s input. The agent picks the smallest allocation whose profiled tail duration, read from the hint slice, fits Janus's "heavier head" policy at $b_k$. Clocks are only loosely synchronized, so the header also carries elapsed time measured by the sender. This bounds the effect of clock skew to a single hop.

We restrict adaptation to CPU quota and per-container concurrency. Both can be changed through cgroups in milliseconds. Memory is left fixed at deployment, because shrinking memory in place is slow and risky. This is a deliberate narrowing, and the evaluation reports it.

There is one further ingredient. When an upstream function starts, its engine sends a speculative early header to the next hop, computed from that function's profiled median duration. This lets the downstream resize overlap with upstream compute. The definitive header then follows with the data.

The program has three questions. First, can in-band sizing match Janus's resource savings without a controller? Second, does it preserve DataFlower's tail latency under Azure-trace bursts? Third, does the advantage grow with controller distance as predicted, which is the regime that layered edge–cloud designs like Sinfonia care about? Sinfonia handles only single-hop offloading at discovery time, not chained workflows.

This differs from SAGE. SAGE also attaches declarative contracts to modular operators, but it interprets them in a centralized control plane. It also warns that coordination overhead dominates tasks under about 10 ms. That warning constrains us: we target functions of 100 ms and above, and we measure per-message header overhead directly. Murakkab solves a global MILP centrally and so sits on the opposite side of the design space. Agent-OSI also treats signed artifacts as controlled cross-layer channels, but it carries them at the protocol layer for settlement, not on a high-throughput data path.

Baselines

The naive reference point is DataFlower as published. It uses decentralized reactive triggering with static, developer-declared worst-case allocations and its own pressure-aware scaling. This baseline tells us how much resource waste exists at all. If budget-carrying headers cannot reduce allocated CPU-seconds below it by a meaningful margin, the idea has no value.

The strongest competitor is a hybrid we will build ourselves: DataFlower's peer-to-peer data plane combined with a Janus-style centralized adapter. After each step, the adapter receives a completion notice, looks up the hints table, and resizes the next container. It is the strongest competitor because it already has both ingredients and differs from our proposal only in where the sizing decision is made. No reported result found on Lacuna for this combination. The closest reported numbers are Janus's 29.9% to 34.7% resource-efficiency gain on its COCO2014 and SQuAD2.0 workflows, and DataFlower's 5.7% to 35.4% P99 reduction over FaaSFlow. We will reproduce both inside one cluster so that all systems share hardware, workflows, hint tables, and arrival traces. For the centralized adapter we will tune batching and polling intervals with the same budget we spend tuning our own agent.

We also include FaaSFlow-style centralized control-flow orchestration, which anchors the comparison to DataFlower's published gap. We include a Hermes-style early-binding scheduler with local processor sharing and static sizes, which isolates the placement effect.

Two ablations isolate the key ingredient. The first carries only the budget, with no hint slice; the local agent scales CPU in proportion to remaining slack. This tests whether the developer-compiled profiles matter. The second carries hints but no speculative early header, which tests whether overlapping the resize with upstream compute is where the latency win comes from.

Beating the strongest baseline means the following. With the controller co-located, our system must reach equal or better SLO attainment at no more than 5% higher allocated CPU-seconds than the centralized hybrid. Once injected round-trip time to the controller exceeds the median function duration, it must show strictly better P99 latency or SLO attainment.

Why not just…?

Why not just keep Janus's centralized adapter and pair it with a peer-to-peer data plane? This is the real threat, and at low round-trip time it may simply tie. Janus's decision time is under 3 ms, but that figure covers computation only. It excludes the notification round trip and any queueing at the adapter during bursts, which Hermes shows is where central queues hurt on heavy-tailed traces. The round-trip sweep in our experiments settles this question directly. If the hybrid matches us across all injected latencies and burst intensities, the proposal reduces to an engineering convenience, and we will report it as such.

Why not just use DataFlower's existing pressure-aware autoscaling? Backpressure signals that a node is overloaded now, but carries no information about how much of a particular request's deadline remains. Local scaling therefore cannot tell a request with lots of slack from one that is about to miss its deadline. The budget-only ablation is a stronger version of this alternative, since it at least knows the slack. The comparison between it and the naive DataFlower baseline measures how much deadline information alone buys.

Why not just provision statically for worst case and accept the waste? Janus's production evidence that half of functions use under 10% of their CPU makes the cost concrete. The early-binding argument from Hermes applies to placement, which we keep static. Static sizing gains nothing from Hermes's result, because resizing in place on an already-chosen worker adds no queue.

Proposed Experiments

All systems run on the same multi-node cluster. The workloads are DataFlower's four workflows (video, image, SVD, WordCount) and Janus's Intelligent Assistant and Video Analyze workflows over COCO2014 and SQuAD2.0. Arrivals are replayed from the Azure Functions public trace, whose skew (0.6% of functions carrying 90% of traffic) produces the bursts that Hermes studies. Metrics are SLO attainment at several deadline tightnesses, P99 end-to-end latency, allocated CPU-seconds and memory-GB-seconds per request, peak sustainable throughput, controller CPU where a controller exists, and per-message header bytes and processing time.

The first decisive check is a sweep of injected round-trip time to the controller, from 0 to 100 ms, using network emulation. We predict a crossover point near the median function duration, because that is when the speculative header can no longer be beaten by a remote decision. The second is profile drift. We perturb function durations by changing input sizes or co-locating interfering work, and measure how fast each system's SLO attainment degrades. Both Janus-derived systems share the same stale tables, so this test separates in-band timing effects from table quality. The third is a granularity sweep that shrinks function duration toward 10 ms. It checks whether header overhead reproduces SAGE's reported coordination floor, and it tells us the regime where the idea stops paying.