TL;DR
This paper proposes a decentralized, auction-based mechanism for placing serverless functions (FaaS) across a "fog" hierarchy (edge nodes, intermediary nodes, and the cloud). By allowing developers to bid on storage and execution, the system enables local nodes to make autonomous offloading decisions that maximize revenue while naturally pushing lower-priority tasks toward the cloud.
What Problem Does This Paper Address?
Fog computing aims to bridge the gap between the cloud and the edge, but it faces a major resource management hurdle: function placement. Edge nodes have very limited compute and storage capacity. When a node is overwhelmed by requests, it must decide which functions to run locally (to maintain low latency) and which to "burst" or offload to the cloud.
Existing solutions often rely on centralized schedulers, which struggle to scale in highly distributed fog environments. Furthermore, there isn't a clear economic model for how to prioritize one developer's function over another when resources are scarce. The authors tackle the challenge of creating a scalable, decentralized way to manage these trade-offs.
Methods
The authors propose a decentralized auction scheme where each fog node acts as an independent auctioneer.
- Two-Part Bidding: Developers attach two distinct bids to their functions:
- Storage Bid ($/s): What they are willing to pay to keep the function code stored on a specific node.
- Execution Bid ($/execution): What they are willing to pay for a single run of that function.
- Local Decision Making:
- Storage: If a node runs out of disk space, it evicts functions with the lowest storage bids.
- Processing: When a burst of requests arrives, the node sorts them by execution bid. It processes the highest bidders locally and pushes the remaining requests "upstream" to intermediary nodes or the cloud.
- Simulation: To evaluate this, the authors built faas4fogsim, a custom simulation tool written in Kotlin. It models a path from the edge to the cloud, accounting for network latency and node-specific capacities.
Datasets
The paper does not use a real-world trace or public dataset. Instead, it utilizes synthetic data generated within their simulation tool:
- Bids: Randomly sampled from a uniform distribution [50; 150].
- Workload: Varying request loads from 100 to 2000 requests per second.
- Topology: A modeled hierarchy of one edge node, one intermediary node, and one cloud node.
The simulation tool itself is open-sourced on GitHub for reproducibility.
Key Insights and Ideas
- Decentralization is the "Secret Sauce": Because each node makes its own decisions based on local bids, there is no need for a global "brain" that knows the state of every node. This makes the system highly scalable.
- Market-Driven Latency: The auction naturally creates a "pay-for-performance" model. Developers who need the ultra-low latency of the edge can bid higher, while those with latency-insensitive tasks will naturally be offloaded to the cloud where costs (and bids) are lower.
- Storage vs. Execution: Separating these two bids is crucial. An edge node might have plenty of CPU but no disk space (or vice versa). This dual-bidding allows the market to reflect the actual physical constraints of the hardware.
- The "Cloud as a Safety Net": The model assumes the cloud has infinite capacity and a base price. This ensures that even the lowest bidder eventually gets their function executed, albeit with higher latency.
Key Results
- Price Sensitivity: In Experiment 1, as the request load increased beyond the edge node's capacity (approx. 166 req/s), the average price of functions executed at the edge rose significantly. This confirms the auction successfully prioritizes high-value requests.
- Latency Trade-offs: As the system becomes overloaded, overall request latency increases linearly. This is because lower-paying requests are forced to travel further up the network hierarchy to find available compute power.
- Storage Eviction: In Experiment 2, once the number of unique executables exceeded the edge node's storage capacity, the node began evicting low-bid functions. This caused the average storage price at the edge to climb while increasing the latency for those evicted functions (which then had to run in the cloud).
Limitations and Future Work
- Simplistic Bidding: The current model uses static bids. In reality, developers might want to use "intelligent agents" that adjust bids based on time of day, current network congestion, or specific geographic needs.
- Lack of Guarantees: The auction model is "best effort." There are no hard Service Level Agreements (SLAs). A developer might bid high but still get offloaded if someone else bids higher a second later.
- Future-Blindness: Nodes currently process requests as they arrive. The authors suggest that future versions could use predictive modeling to "reserve" capacity for expected high-value periodic requests.
- Data Placement: The paper focuses on function code, but many functions require large datasets. Co-managing data placement alongside function placement remains a significant open challenge.
Summary updated