Literature Survey: Serverless Computing

Domain: Distributed Systems, Cloud & Edge
Topic Search: serverless computing
Timeframe: 2021 - 2026

This is a curated survey of recent publications focusing on serverless computing. Results are filtered for top-tier journals and prominent conferences.

📚 Curated Peer-Reviewed Publications

1. Fix: externalizing network I/O in serverless computing

Venue: EuroSys | Year: 2026 | Citations: 2 Authors: Yuhan Deng, Akshay Srivatsan, Sebastian Ingino, Francis Chua, Yasmine Mitchell et al.

We describe a system for serverless computing where users, programs, and the underlying platform share a common representation of a computation: a deterministic procedure, run in an environment of well-specified data or the outputs of other computations. This representation externalizes I/O: data movement over the network is performed exclusively by the platform. Applications can describe the precise data needed at each stage, helping the provider schedule tasks and network transfers to reduce starvation. The design suggests an end-to-end argument for outsourced computing, shifting the service model from “pay-for-effort” to “pay-for-results.”

2. Green or Fast? Learning to Balance Cold Starts and Idle Carbon in Serverless Computing

Venue: CCGrid | Year: 2026 | Citations: 1 Authors: Bowen Sun, Christos D. Antonopoulos, Evgenia Smirni, Bin Ren 0002, Nikolaos Bellas et al.

Serverless computing simplifies cloud deployment but introduces new challenges in managing service latency and carbon emissions. Reducing cold-start latency requires retaining warm function instances, while minimizing carbon emissions favors reclaiming idle resources. This balance is further complicated by time-varying grid carbon intensity and varying workload patterns, under which static keep-alive policies are inefficient. We present LACE-RL, a latency-aware and carbonefficient management framework that formulates serverless pod retention as a sequential decision problem. LACE-RL uses deep reinforcement learning to dynamically tune keep-alive durations, jointly modeling cold-start probability, function-specific latency costs, and real-time carbon intensity. Using the Huawei Public Cloud Trace, we show that LACE-RL reduces cold starts by 51.69% and idle keep-alive carbon emissions by 77.08% compared to Huawei’s static policy, while achieving better latency-carbon trade-offs than state-of-the-art heuristic and singleobjective baselines, approaching Oracle performance.

3. TOSS: Tiering of Serverless Snapshots for Memory-Efficient Serverless Computing

Venue: IPDPS | Year: 2025 | Citations: 0 Authors: Theodore Michailidis, Juno Kim, Linsong Guo, Steven Swanson, Jishen Zhao et al.

Serverless computing is an emerging cloud computing paradigm where users offload functions to serverless platforms that manage their own execution environments. Despite recent advancements on efficient serverless management, we find that cloud providers’ solutions lead to unnecessary memory overheads, and significant memory cost by assuming a single tier of memory (DRAM). In this paper, we evaluate previous serverless works and offer insights about enabling memory tiering for serverless. Based on our insights, we introduce Tiering of Serverless Snapshots (TOSS), a heterogeneous memory mechanism that aims to reduce the total memory cost on serverless platforms, while achieving comparable performance to single-tier solutions. We show that TOSS achieves near optimal memory cost for most functions, while offloading on average 92% of the memory to the slow tier. In addition, TOSS achieves $52 \times$ lower setup time and up to $4.2 \times$ lower invocation time than the state-of-the-art DRAM-only mechanism.

4. Artifact Appendix for Green or Fast? Learning to Balance Cold Starts and Idle Carbon in Serverless Computing

Venue: CCGrid | Year: 2026 | Citations: 0 Authors: Bowen Sun, Christos D. Antonopoulos, Evgenia Smirni, Bin Ren 0002, Nikolaos Bellas et al.

This artifact accompanies the CCGrid'2026 paper on LACE-$R L$, a reinforcement-learning framework that adaptively selects keep-alive durations to co-optimize cold-start latency and carbon emissions under time-varying grid carbon intensity. The artifact provides: (i) an inference-ready Deep Q-Network (DQN) policy model, (ii) a trace-driven simulator implementing the paper’s carbon/latency accounting, (iii) a pre-trained model checkpoint to reproduce the policy behavior reported in the paper, and (iv) demo datasets representing subsets of data used in the paper’s evaluation, processed based on the Huawei Public Cloud Trace [1] and Electricity Maps [2].

5. iRoute: Local Routing Table-based Workflow Management in Serverless Computing

Venue: EuroSys | Year: 2026 | Citations: 0 Authors: Yiming Li, Laiping Zhao, Zhiyuan Su, Guowei Liu, Wenhao Huang 0005 et al.

Serverless computing typically relies on the centralized orchestrator and gateway for function-level and instance-level workflow management. Their intermediary intervention approaches fail to meet the strict microsecond-scale latency requirements of web services. To accelerate workflow execution, prior works have proposed offloading function dependencies to local functions and maintaining connections between frequently invoked instances. However, these methods still suffer from high routing lookup overhead and poor resource efficiency To address these issues, we propose offloading both orchestrating and routing capabilities from global to local to enable universal 1-hop transfers without compromising resource efficiency. We introduce iRoute, a local routing table-based solution for workflow management. It adopts a dual-layer architecture, where local routing controllers make correct routing decisions while concurrently cooperating with a centralized coordinator to ensure consistency across multiple local routing tables. iRoute can achieve sub-millisecond data transmission latency while maintaining high resource efficiency. Our experimental results demonstrate that iRoute outperforms state-of-the-art systems by up to 27.3X on latency, and improve the throughput by up to 6.7X.

⚡ Latest Pre-Prints

1. Towards Demystifying Intra-Function Parallelism in Serverless Computing

Published: 2021-10-22 Authors: Michael Kiener, Mohak Chadha, Michael Gerndt

Serverless computing offers a pay-per-use model with high elasticity and automatic scaling for a wide range of applications. Since cloud providers abstract most of the underlying infrastructure, these services work similarly to black-boxes. As a result, users can influence the resources allocated to their functions, but might not be aware that they have to parallelize them to profit from the additionally allocated virtual CPUs (vCPUs). In this paper, we analyze the impact of parallelization within a single function and container instance for AWS Lambda, Google Cloud Functions (GCF), and Google Cloud Run (GCR). We focus on compute-intensive workloads since they benefit greatly from parallelization. Furthermore, we investigate the correlation between the number of allocated CPU cores and vCPUs in serverless environments. Our results show that the number of available cores to a function/container instance does not always equal the number of allocated vCPUs. By parallelizing serverless workloads, we observed cost savings up to 81% for AWS Lambda, 49% for GCF, and 69.8% for GCR.

2. Straggler Resilient Serverless Computing Based on Polar Codes

Published: 2019-01-21 Authors: Burak Bartan, Mert Pilanci

We propose a serverless computing mechanism for distributed computation based on polar codes. Serverless computing is an emerging cloud based computation model that lets users run their functions on the cloud without provisioning or managing servers. Our proposed approach is a hybrid computing framework that carries out computationally expensive tasks such as linear algebraic operations involving large-scale data using serverless computing and does the rest of the processing locally. We address the limitations and reliability issues of serverless platforms such as straggling workers using coding theory, drawing ideas from recent literature on coded computation. The proposed mechanism uses polar codes to ensure straggler-resilience in a computationally effective manner. We provide extensive evidence showing polar codes outperform other coding methods. We have designed a sequential decoder specifically for polar codes in erasure channels with full-precision input and outputs. In addition, we have extended the proposed method to the matrix multiplication case where both matrices being multiplied are coded. The proposed coded computation scheme is implemented for AWS Lambda. Experiment results are presented where the performance of the proposed coded computation technique is tested in optimization via gradient descent. Finally, we introduce the idea of partial polarization which reduces the computational burden of encoding and decoding at the expense of straggler-resilience.

3. Cost Control and Efficiency Optimization in Maintainability Implementation of Wireless Sensor Networks based on Serverless Computing

Published: 2022-10-28 Authors: Tiannan Gao, Minxian Xu

Wireless sensor network (WSN) has been developed for decades and have performed well in the performance, power consumption, and congestion control. However, the following problems have not been addressed, such as inaccurate cost estimation of device’s lifecycle, highly-coupled engineering development, and low utilization of hardware and software resources during the life cycle of WSN. Therefore, we first propose the conceptual view of maintainability implementation for WSN based on Serverless Computing. The maintainability implementation refers to the ability to meet the WSN product to consume the minimum resources with a higher probability in configuration, trial production, debugging, batch production, deployment, operation, and maintenance phases. And then, we discuss that Serverless Computing can be realized at the software functional level of WSN to decouple the device operation and functional development, greatly improve the reuse of resources and exclude the hardware interference. From the perspective of maintainability and cost control, the concept of Serverless Computing can be used to build WSN platforms, which can support the functions of data collection and data management into functional development that may benefit from exploration through upfront expenditures, thereby significantly reducing design, manufacturing, and operational costs. Finally, based on existing technologies and smart city scenarios, the idea of a WSN platform for Serverless Computing is given with a case study.

4. Supporting Multi-Cloud in Serverless Computing

Published: 2022-09-19 Authors: Haidong Zhao, Zakaria Benomar, Tobias Pfandzelter, Nikolaos Georgantas

Serverless computing is a widely adopted cloud execution model composed of Function-as-a-Service (FaaS) and Backend-as-a-Service (BaaS) offerings. The increased level of abstraction makes vendor lock-in inherent to serverless computing, raising more concerns than previous cloud paradigms. Multi-cloud serverless is a promising emerging approach against vendor lock-in, yet multiple challenges must be overcome to tap its potential. First, we need to be aware of both the performance and cost of each FaaS provider. Second, a multi-cloud architecture must be proposed before deploying a multi-cloud workflow. Domain-specific serverless offerings must then be integrated into the multi-cloud architecture to improve performance or save costs. Moreover, dealing with serverless offerings from multiple providers is challenging. Finally, we require workload portability support for serverless multi-cloud. In this paper, we present a multi-cloud library for cross-serverless offerings. We develop the End Analysis System (EAS) to support comparison among public FaaS providers in terms of performance and cost. Moreover, we design proof-of-concept multi-cloud architectures with domain-specific serverless offerings to alleviate problems such as data gravity. Finally, we deploy workloads on these architectures to evaluate several public FaaS offerings.

5. Cold Start Latency in Serverless Computing: A Systematic Review, Taxonomy, and Future Directions

Published: 2023-10-12 Authors: Muhammed Golec, Guneet Kaur Walia, Mohit Kumar, Felix Cuadrado, Sukhpal Singh Gill, Steve Uhlig

Recently, academics and the corporate sector have paid attention to serverless computing, which enables dynamic scalability and an economic model. In serverless computing, users only pay for the time they actually use resources, enabling zero scaling to optimise cost and resource utilisation. However, this approach also introduces the serverless cold start problem. Researchers have developed various solutions to address the cold start problem, yet it remains an unresolved research area. In this article, we propose a systematic literature review on clod start latency in serverless computing. Furthermore, we create a detailed taxonomy of approaches to cold start latency, which we use to investigate existing techniques for reducing the cold start time and frequency. We have classified the current studies on cold start latency into several categories such as caching and application-level optimisation-based solutions, as well as Artificial Intelligence (AI)/Machine Learning (ML)-based solutions. Moreover, we have analyzed the impact of cold start latency on quality of service, explored current cold start latency mitigation methods, datasets, and implementation platforms, and classified them into categories based on their common characteristics and features. Finally, we outline the open challenges and highlight the possible future directions.

6. Migrating from Microservices to Serverless: An IoT Platform Case Study

Published: 2022-10-09 Authors: Mohak Chadha, Victor Pacyna, Anshul Jindal, Jianfeng Gu, Michael Gerndt

Microservice architecture is the common choice for developing cloud applications these days since each individual microservice can be independently modified, replaced, and scaled. As a result, application development and operating cloud infrastructure were bundled together into what is now commonly called DevOps. However, with the increasing popularity of the serverless computing paradigm and its several advantages such as no infrastructure management, a pay-per-use billing policy, and on-demand fine-grained autoscaling, there is a growing interest in utilizing FaaS and serverless CaaS technologies for refactoring microservices-based applications. Towards this, we migrate a complex IoT platform application onto OpenWhisk (OW) and Google Cloud Run (GCR). We comprehensively evaluate the performance of the different deployment strategies, i.e., Google Kubernetes Engine (GKE)-Standard, OW, and GCR for the IoT platform using different load testing scenarios. Results from our experiments show that while GKE standard performs best for most scenarios, GCR is always cheaper wrt costs.

7. Proactive Serverless Function Resource Management

Published: 2020-10-09 Authors: Erika Hunhoff, Shazal Irshad, Vijay Thurimella, Ali Tariq, Eric Rozner

This paper introduces a new primitive to serverless language runtimes called freshen. With freshen, developers or providers specify functionality to perform before a given function executes. This proactive technique allows for overheads associated with serverless functions to be mitigated at execution time, which improves function responsiveness. We show various predictive opportunities exist to run freshen within reasonable time windows. A high-level design and implementation are described, along with preliminary results to show the potential benefits of our scheme.

8. GreenCourier: Carbon-Aware Scheduling for Serverless Functions

Published: 2023-10-31 Authors: Mohak Chadha, Thandayuthapani Subramanian, Eishi Arima, Michael Gerndt, Martin Schulz, Osama Abboud

This paper presents GreenCourier, a novel scheduling framework that enables the runtime scheduling of serverless functions across geographically distributed regions based on their carbon efficiencies. Our framework incorporates an intelligent scheduling strategy for Kubernetes and supports Knative as the serverless platform. To obtain real-time carbon information for different geographical regions, our framework supports multiple marginal carbon emissions sources such as WattTime and the Carbon-aware SDK. We comprehensively evaluate the performance of our framework using the Google Kubernetes Engine and production serverless function traces for scheduling functions across Spain, France, Belgium, and the Netherlands. Results from our experiments show that compared to other approaches, GreenCourier reduces carbon emissions per function invocation by an average of 13.25%.

9. Scaling a Variant Calling Genomics Pipeline with FaaS

Published: 2023-12-12 Authors: Aitor Arjona, Arnau Gabriel-Atienza, Sara Lanuza-Orna, Xavier Roca-Canals, Ayman Bourramouss, Tyler K. Chafin, Lucio Marcello, Paolo Ribeca, Pedro García-López

With the escalating complexity and volume of genomic data, the capacity of biology institutions’ HPC faces limitations. While the Cloud presents a viable solution for short-term elasticity, its intricacies pose challenges for bioinformatics users. Alternatively, serverless computing allows for workload scalability with minimal developer burden. However, porting a scientific application to serverless is not a straightforward process. In this article, we present a Variant Calling genomics pipeline migrated from single-node HPC to a serverless architecture. We describe the inherent challenges of this approach and the engineering efforts required to achieve scalability. We contribute by open-sourcing the pipeline for future systems research and as a scalable user-friendly tool for the bioinformatics community.

10. Universal Workers: A Vision for Eliminating Cold Starts in Serverless Computing

Published: 2025-05-26 Authors: Saman Akbari, Manfred Hauswirth

Serverless computing enables developers to deploy code without managing infrastructure, but suffers from cold start overhead when initializing new function instances. Existing solutions such as “keep-alive” or “pre-warming” are costly and unreliable under bursty workloads. We propose universal workers, which are computational units capable of executing any function with minimal initialization overhead. Based on an analysis of production workload traces, our key insight is that requests in Function-as-a-Service (FaaS) platforms show a highly skewed distribution, with most requests invoking a small subset of functions. We exploit this observation to approximate universal workers through locality groups and three-tier caching (handler, install, import). With this work, we aim to enable more efficient and scalable FaaS platforms capable of handling diverse workloads with minimal initialization overhead.

🧠 Architectural & Methodological Insights

Trajectory: The subfield is converging on resource‑aware, heterogeneous, and decentralized serverless architectures. Instead of treating the platform as a black‑box “function‑as‑service” layer, recent works expose network, memory, carbon, and orchestration dimensions to the scheduler. This enables fine‑grained optimization across latency, cost, and sustainability, and paves the way for edge‑centric, multi‑cloud deployments where the control plane itself is distributed.

🚀 Critical Research Gaps

1. Unified Modeling of Heterogeneous Resources (CPU, Memory Tiers, Network, Carbon)

   • Fix: externalizing network I/O… focuses on deterministic I/O, while TOSS tackles memory tiering and LACE‑RL adds carbon. No existing work provides a joint analytical or learning model that simultaneously reasons about all these resources. Consequently, optimization decisions are made in isolation, potentially leading to sub‑optimal trade‑offs.

2. Robust Evaluation under Real‑World, Multi‑Tenant Workloads

   • The evaluation of iRoute and Universal Workers relies on synthetic or trace‑driven workloads with limited contention. Likewise, GreenCourier and LACE‑RL use a single provider’s trace (Huawei or GKE). There is a lack of large‑scale, multi‑tenant, cross‑region experiments that capture interference, burstiness, and provider‑specific throttling, making it unclear how these techniques scale in production clouds.

3. Formal Guarantees for Decentralized Orchestration

   • iRoute demonstrates empirical latency gains but does not provide formal consistency or safety guarantees (e.g., eventual consistency, deadlock freedom) when local routing tables diverge from the global coordinator. This gap hampers adoption in mission‑critical services that require provable correctness.

4. Portability and Standardized Interfaces for Carbon‑Aware Scheduling

   • Supporting Multi‑Cloud in Serverless Computing proposes a library for cross‑provider comparison, yet LACE‑RL and GreenCourier are tightly coupled to a single provider’s APIs and carbon data sources. A standardized abstraction layer for carbon metrics and scheduling actions is missing, limiting reproducibility and broader impact.

💡 High‑Impact Open Problems

1. Joint Multi‑Objective Scheduler for Heterogeneous Serverless Resources
   Problem Statement: Design a scheduler that simultaneously optimizes (i) network‑aware placement (as in Fix), (ii) memory‑tier allocation for snapshots (as in TOSS), (iii) carbon‑intensity‑aware keep‑alive policies (as in LACE‑RL), and (iv) latency constraints.
   Research Tasks:

   • Formulate a unified Markov Decision Process (MDP) or constrained reinforcement‑learning problem that captures all resource dimensions.
   • Develop a scalable approximation algorithm (e.g., hierarchical RL) that can be deployed in real‑time across thousands of functions.
   • Validate on a multi‑cloud testbed with heterogeneous hardware (DRAM + NVM, edge nodes) and real‑time carbon feeds.

2. Formal Consistency Model for Decentralized Serverless Orchestration
   Problem Statement: Provide a mathematically rigorous consistency model for local routing‑table based orchestration (building on iRoute) that guarantees correct workflow execution despite asynchronous updates and partial failures.
   Research Tasks:

   • Define a state‑based or operation‑based CRDT (Conflict‑Free Replicated Data Type) that captures routing table updates and workflow dependencies.
   • Prove safety (no lost or duplicated invocations) and liveness (eventual progress) properties under realistic network partitions.
   • Implement a prototype that integrates the CRDT into an existing serverless platform (e.g., OpenWhisk) and measure overhead versus the original iRoute implementation.

3. Standardized Carbon‑Aware Serverless API and Benchmark Suite
   Problem Statement: Create an open, provider‑agnostic API that exposes carbon intensity, regional emission factors, and scheduling hooks, together with a benchmark suite that evaluates carbon‑aware policies across multiple clouds.
   Research Tasks:

   • Design a REST/GRPC interface (e.g., CarbonMetrics.getIntensity(region, timestamp)) and extend existing FaaS SDKs to accept carbon‑aware placement hints.
   • Assemble a reproducible benchmark comprising diverse workloads (CPU‑bound, I/O‑bound, bursty) and real‑time carbon data from at least three public providers.
   • Release the API specification and benchmark as a community artifact, and demonstrate its use by re‑implementing LACE‑RL and GreenCourier in a multi‑provider setting.

These problems directly address the identified gaps and, if solved, would substantially advance the theoretical foundations, practical robustness, and sustainability of next‑generation serverless systems.