Pith. sign in

REVIEW 5 major objections 6 minor 57 references

Making Serverless Computing Extensible: A Case Study of Serverless Data Analytics

T0 review · 5 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper argues that serverless platforms can avoid the choice between general-purpose ease and application-specific performance by making the control plane (scaling and scheduling) extensible while keeping the data plane shared.

desk verdict A clear vision for an extensible serverless control plane, backed by a thin prototype; the abstraction is genuinely new, but the evaluation is too narrow to carry the broad claims. read the letter →

arxiv 2507.11929 v1 pith:VRYXKHHN submitted 2025-07-16 cs.DC

Minchen Yu , Yinghao Ren , Jiamu Zhao , Jiaqi Li This is my paper · ORCID
classification cs.DC
keywords serverlesscomputingFaaSextensibledesigncontrolplanedataanalyticsdecisionworkflowsfunctionschedulingresourcesharing
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper argues that the standard dilemma in serverless computing — general-purpose platforms underperform on complex workloads, while application-specific systems sacrifice ease of use and shared resource efficiency — can be resolved by making the platform extensible. Its central claim is that for serverless analytics, the optimizations that matter are control-plane decisions: how many function instances to scale, which join algorithm to use, and how to schedule functions onto nodes, all driven by data distribution and node state. Proteus is a prototype that exposes these decisions to developers through a decision-workflow abstraction, while keeping a general-purpose data plane for data sharing and function startup. Preliminary measurements on a TPC-DS subquery show that a developer-customized dynamic strategy outperforms static hash and merge join strategies, and that low-priority background functions can fill idle CPU during shuffle phases. If the claim holds, domain-specialized performance and shared, easy-to-use serverless operation are not mutually exclusive.

What carries the argument

The mechanism carrying the argument is the decision workflow, an abstraction in the control plane that represents a group of functions as a decision node and an entire application as a workflow of such nodes. Each decision node takes runtime system knowledge — data distribution, node status, available slots — as input and outputs a decision tuple specifying which function to invoke, how many instances to scale, and which scheduling policy to apply, such as round-robin or packing. Decision workflows extend ordinary function workflows by letting developers embed application-specific scaling and scheduling logic that executes dynamically during query runs. Supporting this is a decentralized control plane: one global controller coordinates resource allocation and maintains a system-wide view, while per-application private controllers run the custom decision logic and manage application-level information. The data plane itself is deliberately left generic and shared, relying on existing data-plane optimizations as complementary to the control-plane extensibility.

What would settle it

Run a data-movement-heavy analytical query, such as a large multi-way join with heavy shuffle, on a platform where developers customize only scaling and scheduling while the data plane is fixed and generic, then apply a data-plane-only optimization such as serialization-free state transfer; if that optimization yields a speedup no control-plane decision can match, the control-plane-only hypothesis fails. A simpler check: compare a dynamic custom strategy against a static strategy that is optimal for each data size, and verify whether the dynamic strategy's advantage persists across distributions and cluster sizes.

Watch

Extended reading notes

Core claim

The core discovery is a design principle: a serverless platform can meet ease of use, generality, and satisfactory performance simultaneously by making only its control plane extensible. The paper's key insight is that application-specific optimizations for analytics — choosing between sort-merge join and broadcast hash join, setting the degree of function parallelism, and selecting round-robin versus packing scheduling — depend on system-level knowledge such as data sizes, node slots, and data distribution, and all of that lives in the control plane. Data-plane behaviors such as data sharing and function startup are largely independent of application semantics, so they can be provided once in a shared, efficient form. Proteus realizes this with decision nodes and decision workflows: each decision node consumes runtime data distribution and node status and emits a tuple of function, scale, and schedule, executed as part of the end-to-end workflow at runtime. The prototype's experiments show a dynamic custom strategy switching between join implementations and scheduling policies improves query completion time over static strategies, and that a global-and-private controller arrangement lets low-priority tasks use idle resources during query shuffle phases.

Load-bearing premise

The design stands on the assumption that for serverless analytics the performance-critical optimizations are all in the control plane — how many function instances run and where they run — so the shared data plane can stay generic; if significant speedups require application-specific data movement or startup behavior, or if exposing system state to developers breaks tenant isolation, the claimed combination of performance and generality collapses.

Editorial extensions

If this is right

  • Application developers can encode domain knowledge directly into the platform through a small interface — for instance, when to switch between hash join and sort-merge join, how many function instances to scale, and whether to pack or round-robin — instead of building a separate scheduling layer.
  • Because the data plane is shared and general, existing data-plane optimizations can be integrated into Proteus without rearchitecting each application, so the platform can accumulate improvements across domains.
  • In multi-tenant operation, low-priority delay-tolerant functions can be scheduled into the CPU idleness left by data-shuffle phases, raising overall resource utilization without delaying the query.
  • Proteus's control plane can be layered on existing FaaS systems that already separate control from data plane, making the extensibility idea portable to production platforms.
  • For simple workloads with no customization need, Proteus falls back to default function workflows and behaves like a standard FaaS platform, preserving ease of use.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The control-plane/data-plane split predicts which applications will benefit from Proteus: workloads whose performance is governed by scaling and scheduling, such as analytics joins, inference batching, and graph partitioning, should transfer with little loss, while workloads whose performance hinges on specialized data movement will not; the paper does not run that comparison.
  • Exposing data distribution and node status to developers creates a cross-tenant information channel that the paper does not address: a developer could infer other tenants' data sizes or resource topology from the system knowledge Proteus provides, raising isolation questions.
  • A natural, testable extension is quantifying developer effort: if decision workflows are sufficient, implementing an analytics operator on Proteus should require much less code than building a specialized serverless system, a claim the prototype's construction suggests but does not measure.
  • The same abstraction should carry to machine-learning inference serving, where the control-plane choices are batch size, model placement, and swapping; the paper lists this as future work, so it remains an untested inference rather than a demonstrated result.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 6 minor

Summary. The paper proposes an extensible design principle for serverless computing: keep a shared general-purpose FaaS platform but let developers customize control-plane behaviors (scaling and scheduling) through a new decision-workflow abstraction. Proteus is a prototype implementing this principle, with a decentralized control plane and a data plane using shared-memory data exchange. The authors evaluate Proteus on a single TPC-DS sub-query on a 6-node cluster, comparing three internally defined strategies (static merge join, static hash join, dynamic), and report CPU allocation under co-running background functions. They discuss generalization to other domains and integration with existing FaaS as future work.

Significance. If the central design principle is validated, it offers a useful way to mitigate the tradeoff between general-purpose FaaS and specialized serverless systems. The decision-workflow abstraction is a clean interface for embedding domain knowledge into scaling and scheduling, and the decentralized controller design with global and private controllers is reasonable. The paper honestly frames results as preliminary and discusses limitations. However, the evaluation as presented does not establish the key attribution claim: it lacks external baselines, tests only one query, and the dynamic strategy's thresholds appear fitted to the motivating measurements. The significance is therefore conditional on a stronger experimental demonstration.

major comments (5)
  1. [§4, §6] Section 4 asserts the key insight that application-specific optimizations occur mainly in the control plane while data-plane behaviors are 'largely independent of application semantics.' This dichotomy is load-bearing but not demonstrated. The evaluation in §6 cannot isolate the effect of the extensible control plane: Fig. 7 compares only three Proteus-internal control policies, and the prototype itself uses shared-memory data exchange, which is a data-plane optimization. Moreover, the paper's own related-work discussion lists analytics-specific data-plane mechanisms (SONIC [33] 'application-aware data passing'; Ditto [21] and MinFlow [26] redesigned data passing; Pocket [24] analytics-specific storage). The authors should provide a comparison against a general-purpose FaaS platform (e.g., AWS Lambda with PyWren) and a specialized analytics system (e.g., Ditto or MinFlow), or otherwise show that the observed gains are attributable to the control-plane abstraction rather than to data-plane mechanisms.
  2. [§6, Fig. 7] The experimental evaluation is too narrow to support the abstract's claim that Proteus 'effectively optimizes analytical query execution.' Fig. 7 reports one TPC-DS sub-query on a 6-node cluster, and the only comparators are two static strategies defined by the authors within Proteus. There is no comparison to an existing general-purpose serverless platform or to an analytics-specialized serverless system, and no error bars or repeated runs are reported. At minimum, the paper should either add such baselines and additional queries, or scale back the claim to demonstrating the feasibility of the decision-workflow abstraction on a single workload.
  3. [§5.1, Fig. 6; §6] The dynamic strategy's advantage over static strategies is partly by construction. The thresholds T1 and T2 in Fig. 6 are described as 'predefined,' and the text says the decision rule is 'based on observations in Fig. 4,' meaning the same measurements that motivate the design are used to fit the policy. The evaluation in Fig. 7 then tests this fitted policy on the same join scenario. To break the circularity, the authors should report the values of T1 and T2 and the scaling parameter 'a', and validate DYN on held-out data sizes, distributions, and cluster configurations, or derive the thresholds from an independent model.
  4. [§3, §6] There is a factual inconsistency in the experimental setup. Section 3 states that Fig. 4 was produced 'using a 12-node cluster (detailed testbed described in §6),' but §6 says the prototype is deployed on a 6-node cluster of c5.2xlarge instances. Since the DYN decision thresholds in Fig. 6 are justified by the Fig. 4 measurements, it matters which cluster size generated Fig. 4. Please correct the inconsistency and state the testbed for each figure.
  5. [§6, Fig. 8] The resource-sharing experiment shows CPU allocation rates but does not report the query completion-time overhead relative to running the query alone, nor the throughput or utility of the background functions. The text claims Proteus improves resource efficiency 'without compromising the performance of critical workloads,' but Fig. 8 alone does not establish that no compromise occurred; the query time under co-tenancy is not shown. Please add a quantitative comparison (query latency with and without background tasks, background task progress, and a baseline sharing policy).
minor comments (6)
  1. [Fig. 3] The caption contains a typo: 'Join exmaple' should be 'Join example.'
  2. [§6, Fig. 7] Fig. 7 shows only aggregate bars per data size; consider adding standard deviations or per-run markers to indicate variance.
  3. [§5.1, Fig. 6] The interface example uses an undefined scaling denominator 'a' and undefined thresholds T1 and T2; please define these or clearly mark them as illustrative placeholders.
  4. [§3] The term 'normalized cost (measured as resource-time)' is not defined; specify the formula and units used in Fig. 4 (b) and (d).
  5. [§7.1] The discussion of complexity is qualitative; a quantitative measurement of decision-node execution overhead would strengthen the argument.
  6. [Abstract] The abstract says 'preliminary results show that Proteus's prototype effectively optimizes analytical query execution'; consider wording this as 'can effectively optimize' or 'demonstrates feasibility' to match the limited evaluation.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the measured DYN result is a disclosed, domain-informed policy evaluation rather than a prediction fitted to its own output, and the cited prior work is not load-bearing self-citation.

full rationale

The paper's central claim is that an extensible control plane with decision workflows lets developers encode domain-specific scaling and scheduling logic. The DYN strategy in Fig. 7 is explicitly described as using observations from Fig. 4: 'Based on observations in Fig. 4, merge-join performs better in large clusters and when data volumes across tables are balanced.' This is transparently a microbenchmark-informed policy, not a hidden fit passed off as an independent prediction. The evaluation measures end-to-end query latency of Proteus running that policy, which tests whether the platform can execute a custom control-plane strategy; the advantage of DYN over static strategies is a measured outcome, not a quantity defined by the inputs. The thresholds T1 and T2 are not fitted values reported as predictions; they are parameters of an example decision node. Similarly, the resource-sharing experiment uses independent background workloads from production practice and does not reduce to a fitted parameter. Self-citations appear only as pointers to a broader body of data-plane research (e.g., [50], [51]) and are not load-bearing support for the paper's design principle or evaluation. The control-plane/data-plane dichotomy is asserted as a design hypothesis, but an unsupported assumption is a correctness risk, not circularity. No equation, definition, or cited result in the paper is shown to be equivalent to its own inputs, so the derivation chain is not circular.

Assumptions & free parameters 2 free parameters · 4 assumptions · 1 invented entities

The paper introduces no physical entities. It does rely on several domain assumptions about where performance leverage lives and about the feasibility of exposing control-plane knowledge to developers. Free parameters appear in the example decision logic, and the main invented abstraction is the decision workflow.

free parameters (2)
  • Decision node thresholds T1 and T2 = not specified
    In the Fig. 6 example, T1 and T2 determine whether to use merge_join or hash_join and affect the scheduling decision. They are based on the Fig. 4 measurements but are not given values or justified independently.
  • Scaling denominator 'a' in decision node example = not specified
    Line 11 of Fig. 6 uses scale = (sizeA + sizeB) / a with 'a' undefined. If implemented, this constant must be chosen and affects function parallelism.
assumptions (4)
  • domain assumption Application-specific optimizations for serverless analytics primarily live in the control plane, while the data plane is application-agnostic.
    Stated as the 'key insight' in Section 4 and used to justify exposing only control-plane extensibility. If important optimization leverage also lives in the data plane, the design would not deliver specialized performance.
  • domain assumption Developers can encode effective domain knowledge into decision workflows using the provided APIs.
    Section 5.1 assumes experienced developers can set thresholds and policies correctly; the Fig. 6 example relies on predefined thresholds and cluster knowledge.
  • domain assumption A shared-state, Omega-like decentralized control plane preserves correct global resource allocation under multi-tenant contention.
    Section 5.2 borrows Omega's shared-state scheduling [40] without proof that it works correctly in multi-tenant FaaS with heterogeneous applications.
  • domain assumption Existing data-plane optimization techniques can be integrated into Proteus without changing application semantics.
    Section 5 states that Proteus 'can integrate existing solutions from a rich body of related research,' but no implementation or validation is provided.
invented entities (1)
  • decision node / decision workflow abstraction
    purpose: Let developers customize function scaling and scheduling inside a serverless platform.
    A software abstraction introduced in Section 5.1; the prototype provides the only evidence, and no independent validation outside this paper exists yet.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Making Serverless Computing Extensible: A Case Study of Serverless Data Analytics." pith.science (2026). https://pith.science/paper/VRYXKHHN

@misc{pith2026250711929,
  author       = {Pith},
  title        = {Pith review of: Making Serverless Computing Extensible: A Case Study of Serverless Data Analytics},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VRYXKHHN}},
  note         = {Machine review of arXiv:2507.11929}
}
read the original abstract

Serverless computing has attracted a broad range of applications due to its ease of use and resource elasticity. However, developing serverless applications often poses a dilemma -- relying on general-purpose serverless platforms can fall short of delivering satisfactory performance for complex workloads, whereas building application-specific serverless systems undermines the simplicity and generality. In this paper, we propose an extensible design principle for serverless computing. We argue that a platform should enable developers to extend system behaviors for domain-specialized optimizations while retaining a shared, easy-to-use serverless environment. We take data analytics as a representative serverless use case and realize this design principle in Proteus. Proteus introduces a novel abstraction of decision workflows, allowing developers to customize control-plane behaviors for improved application performance. Preliminary results show that Proteus's prototype effectively optimizes analytical query execution and supports fine-grained resource sharing across diverse applications.

Figures

Figures reproduced from arXiv: 2507.11929 by the authors.

Figure 1
Figure 1. Serverless paradigm and the key stakeholders. [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Developing applications atop three kinds of server [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Join exmaple. Characteristics of serverless analytics. Serverless computing has become an appealing option for analytical workloads that de￾mand launching thousands of parallel tasks for data processing, with tasks running as highly elastic functions. However, achieving efficient serverless analytics remains a significant challenge. The system must adopt efficient execution plans—scheduling and co￾ordinating paralle… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Completion times and normalized costs of [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Comparison between existing general-purpose [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 7
Figure 7. Figure 7: Query performance under various strategies. [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: Resource allocation rates of Proteus. outperforms the others due to its adaptability to different cases: for 2 GB data, DYN consolidates all functions on a single node to eliminate shuffle overhead (i.e., function packing); for 4 GB and 6 GB data, DYN dynamically switc…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

57 extracted references · 55 canonical work pages

  1. [33]

    SONIC: Application-aware data passing for chained serverless applications

    Ashraf Mahgoub, Karthick Shankar, Subrata Mitra, and Ana Klimovic. SONIC: Application-aware data passing for chained serverless applications. In Proc. USENIX ATC, 2021

    work page 2021

  2. [21]

    Ditto: Efficient serverless analytics with elastic parallelism

    Chao Jin, Zili Zhang, Xingyu Xiang, Songyun Zou, Gang Huang, Xuanzhe Liu, and Xin Jin. Ditto: Efficient serverless analytics with elastic parallelism. In Proc. ACM SIGCOMM, 2023

    work page 2023

  3. [26]

    Tao Li, Yongkun Li, Wenzhe Zhu, Yinlong Xu, and John C. S. Lui. MinFlow: High- performance and cost-efficient data passing for i/o-intensive stateful serverless analytics. In Proc. USENIX FAST, 2024

    work page 2024

  4. [24]

    Pocket: Elastic ephemeral storage for serverless analytics

    Ana Klimovic, Yawen Wang, Patrick Stuedi, Animesh Trivedi, Jonas Pfefferle, and Christos Kozyrakis. Pocket: Elastic ephemeral storage for serverless analytics. In Proc. USENIX OSDI, 2018

    work page 2018

  5. [1]

    https://www.alibabacloud.com/product/ function-compute

    Alibaba Cloud Function Compute. https://www.alibabacloud.com/product/ function-compute

    work page

  6. [2]

    https://aws.amazon.com/lambda/

    AWS Lambda. https://aws.amazon.com/lambda/

    work page

  7. [3]

    https://azure.microsoft.com/en-us/services/functions/

    Azure Functions. https://azure.microsoft.com/en-us/services/functions/

    work page

  8. [4]

    https://cloud.google.com/functions

    Google Cloud Functions. https://cloud.google.com/functions

    work page

Show all 57 references
  1. [5]

    https://docs.aws.amazon.com/wellarchitected/ latest/serverless-applications-lens/scenarios.html

    Serverless applications scenarios. https://docs.aws.amazon.com/wellarchitected/ latest/serverless-applications-lens/scenarios.html

  2. [6]

    SAND: Towards high-performance serverless computing

    Istemi Ekin Akkus, Ruichuan Chen, Ivica Rimac, Manuel Stein, Klaus Satzke, Andre Beck, Paarijaat Aditya, and Volker Hilt. SAND: Towards high-performance serverless computing. In Proc. USENIX ATC, 2018

    2018

  3. [7]

    BATCH: Machine learning inference serving on serverless platforms with adaptive batching

    Ahsan Ali, Riccardo Pinciroli, Feng Yan, and Evgenia Smirni. BATCH: Machine learning inference serving on serverless platforms with adaptive batching. In 6 Proc. ACM/IEEE Supercomputing, 2020

    2020

  4. [8]

    Optimizing inference serving on serverless platforms

    Ahsan Ali, Riccardo Pinciroli, Feng Yan, and Evgenia Smirni. Optimizing inference serving on serverless platforms. In Proc. VLDB Endow., 2022

    2022

  5. [9]

    Voelker, and George Porter

    Lixiang Ao, Liz Izhikevich, Geoffrey M. Voelker, and George Porter. Sprocket: A serverless video processing framework. In Proc. ACM SoCC, 2018

    2018

  6. [10]

    Lixiang Ao, George Porter, and Geoffrey M. Voelker. FaaSnap: FaaS made fast using snapshot-based VMs. In Proc. ACM EuroSys, 2022

    2022

  7. [11]

    SEUSS: skip redundant paths to make serverless fast

    James Cadden, Thomas Unger, Yara Awad, Han Dong, Orran Krieger, and Jonathan Appavoo. SEUSS: skip redundant paths to make serverless fast. In Proc. ACM EuroSys, 2020

    2020

  8. [12]

    Cirrus: A serverless framework for end-to-end ML workflows

    Joao Carreira, Pedro Fonseca, Alexey Tumanov, Andrew Zhang, and Randy Katz. Cirrus: A serverless framework for end-to-end ML workflows. In Proc. ACM SoCC, 2019

    2019

  9. [13]

    Wukong: a scalable and locality-enhanced framework for serverless parallel computing

    Benjamin Carver, Jingyuan Zhang, Ao Wang, Ali Anwar, Panruo Wu, and Yue Cheng. Wukong: a scalable and locality-enhanced framework for serverless parallel computing. In Proc. ACM SoCC, 2021

    2021

  10. [14]

    Wiener, Shridhar Iyer, Anshul Jaiswal, Ran Lei, Nikhil Simha, Wei Wang, Kevin Wilfong, Tim Williamson, and Serhat Yilmaz

    Guoqiang Jerry Chen, Janet L. Wiener, Shridhar Iyer, Anshul Jaiswal, Ran Lei, Nikhil Simha, Wei Wang, Kevin Wilfong, Tim Williamson, and Serhat Yilmaz. Realtime data processing at facebook. In Proc. ACM SIGMOD, 2016

    2016

  11. [15]

    Serverless computing on heterogeneous computers

    Dong Du, Qingyuan Liu, Xueqiang Jiang, Yubin Xia, Binyu Zang, and Haibo Chen. Serverless computing on heterogeneous computers. In Proc. ACM ASPLOS, 2022

    2022

  12. [16]

    Catalyzer: Sub-millisecond startup for serverless computing with initialization-less booting

    Dong Du, Tianyi Yu, Yubin Xia, Binyu Zang, Guanglu Yan, Chenggang Qin, Qixuan Wu, and Haibo Chen. Catalyzer: Sub-millisecond startup for serverless computing with initialization-less booting. In Proc. ACM ASPLOS, 2020

    2020

  13. [17]

    From laptop to lambda: Out- sourcing everyday jobs to thousands of transient functional containers

    Sadjad Fouladi, Francisco Romero, Dan Iter, Qian Li, Shuvo Chatterjee, Christos Kozyrakis, Matei Zaharia, and Keith Winstein. From laptop to lambda: Out- sourcing everyday jobs to thousands of transient functional containers. In Proc. USENIX ATC, 2019

    2019

  14. [18]

    Encoding, fast and slow: Low-latency video processing using thousands of tiny threads

    Sadjad Fouladi, Riad S Wahby, Brennan Shacklett, Karthikeyan Vasuki Balasubra- maniam, William Zeng, Rahul Bhalerao, Anirudh Sivaraman, George Porter, and Keith Winstein. Encoding, fast and slow: Low-latency video processing using thousands of tiny threads. In Proc. USENIX NSDI, 2017

    2017

  15. [19]

    ServerlessLLM: Locality-enhanced serverless inference for large language models

    Yao Fu, Leyang Xue, Yeqi Huang, Andrei-Octavian Brabete, Dmitrii Ustiugov, Yuvraj Patel, and Luo Mai. ServerlessLLM: Locality-enhanced serverless inference for large language models. In Proc. USENIX OSDI, 2024

    2024

  16. [20]

    Nightcore: Efficient and scalable serverless computing for latency-sensitive, interactive microservices

    Zhipeng Jia and Emmett Witchel. Nightcore: Efficient and scalable serverless computing for latency-sensitive, interactive microservices. In Proc. ACM ASPLOS, 2021

    2021

  17. [22]

    Occupy the cloud: Distributed computing for the 99%

    Eric Jonas, Qifan Pu, Shivaram Venkataraman, Ion Stoica, and Benjamin Recht. Occupy the cloud: Distributed computing for the 99%. In Proc. ACM SoCC, 2017

    2017

  18. [23]

    Yadwadkar, and Christos Kozyrakis

    Kostis Kaffes, Neeraja J. Yadwadkar, and Christos Kozyrakis. Centralized core- granular scheduling for serverless functions. In Proc. ACM SoCC, 2019

    2019

  19. [25]

    Function as a function

    Tom Kuchler, Michael Giardino, Timothy Roscoe, and Ana Klimovic. Function as a function. In Proceedings of the 2023 ACM Symposium on Cloud Computing , 2023

    2023

  20. [27]

    DataFlower: Exploiting the data-flow paradigm for serverless workflow orches- tration

    Zijun Li, Chuhao Xu, Quan Chen, Jieru Zhao, Chen Chen, and Minyi Guo. DataFlower: Exploiting the data-flow paradigm for serverless workflow orches- tration. In Proc. ACM ASPLOS, 2023

    2023

  21. [28]

    Fuyao: Dpu-enabled direct data transfer for server- less computing

    Guowei Liu, Laiping Zhao, Yiming Li, Zhaolin Duan, Sheng Chen, Yitao Hu, Zhiyuan Su, and Wenyu Qu. Fuyao: Dpu-enabled direct data transfer for server- less computing. In Proc. ACM ASPLOS, 2024

    2024

  22. [29]

    FaaSGraph: Enabling scalable, efficient, and cost-effective graph processing with serverless computing

    Yushi Liu, Shixuan Sun, Zijun Li, Quan Chen, Sen Gao, Bingsheng He, Chao Li, and Minyi Guo. FaaSGraph: Enabling scalable, efficient, and cost-effective graph processing with serverless computing. In Proc. ACM ASPLOS, 2024

    2024

  23. [30]

    Understanding and optimizing workloads for unified resource management in large cloud platforms

    Chengzhi Lu, Huanle Xu, Kejiang Ye, Guoyao Xu, Liping Zhang, Guodong Yang, and Chengzhong Xu. Understanding and optimizing workloads for unified resource management in large cloud platforms. In Proc. ACM EuroSys, 2023

    2023

  24. [31]

    Serialization/deserialization-free state transfer in serverless workflows

    Fangming Lu, Xingda Wei, Zhuobin Huang, Rong Chen, Minyu Wu, and Haibo Chen. Serialization/deserialization-free state transfer in serverless workflows. In Proc. ACM EuroSys, 2024

    2024

  25. [32]

    Dilu: Enabling gpu resourcing-on-demand for serverless dl serving via introspective elasticity

    Cunchi Lv, Xiao Shi, Zhengyu Lei, Jinyue Huang, Wenting Tan, Xiaohui Zheng, and Xiaofang Zhao. Dilu: Enabling gpu resourcing-on-demand for serverless dl serving via introspective elasticity. In Proc. ACM ASPLOS, 2025

    2025

  26. [34]

    Lambada: Interactive data analytics on cold data using serverless cloud infrastructure

    Ingo Müller, Renato Marroquín, and Gustavo Alonso. Lambada: Interactive data analytics on cold data using serverless cloud infrastructure. In Proc. ACM SIGMOD, 2020

    2020

  27. [35]

    Starling: A scalable query engine on cloud functions

    Matthew Perron, Raul Castro Fernandez, David DeWitt, and Samuel Madden. Starling: A scalable query engine on cloud functions. In Proc. ACM SIGMOD , 2020

    2020

  28. [36]

    Shuffling, fast and slow: Scalable analytics on serverless infrastructure

    Qifan Pu, Shivaram Venkataraman, and Ion Stoica. Shuffling, fast and slow: Scalable analytics on serverless infrastructure. In Proc. USENIX NSDI, 2019

    2019

  29. [37]

    Benjamin Reidys, Pantea Zardoshti, Íñigo Goiri, Celine Irvene, Daniel S. Berger, Haoran Ma, Kapil Arya, Eli Cortez, Taylor Stark, Eugene Bak, Mehmet Iyigun, Stanko Novakovic, Lisa Hsu, Karel Trueba, Abhisek Pan, Chetan Bansal, Saravan Rajmohan, Jian Huang, and Ricardo Bianchin...

    2025

  30. [38]

    XFaaS: Hyperscale and low cost serverless functions at meta

    Alireza Sahraei, Soteris Demetriou, Amirali Sobhgol, Haoran Zhang, Abhigna Nagaraja, Neeraj Pathak, Girish Joshi, Carla Souza, Bo Huang, Wyatt Cook, Andrii Golovei, Pradeep Venkat, Andrew Mcfague, Dimitrios Skarlatos, Vipul Patel, Ravinder Thind, Ernesto Gonzalez, Yun Jin, and...

    2023

  31. [39]

    Yadwadkar, Raluca Ada Popa, Joseph E

    Johann Schleier-Smith, Vikram Sreekanti, Anurag Khandelwal, Joao Carreira, Neeraja J. Yadwadkar, Raluca Ada Popa, Joseph E. Gonzalez, Ion Stoica, and David A. Patterson. What serverless computing is and should become: the next phase of cloud computing. Commun. ACM, 64(5):76–84, 2021

    2021

  32. [40]

    Omega: flexible, scalable schedulers for large compute clusters

    Malte Schwarzkopf, Andy Konwinski, Michael Abd-El-Malek, and John Wilkes. Omega: flexible, scalable schedulers for large compute clusters. In Proc. ACM EuroSys, 2013

    2013

  33. [41]

    Faasm: Lightweight isolation for efficient stateful serverless computing

    Simon Shillaker and Peter Pietzuch. Faasm: Lightweight isolation for efficient stateful serverless computing. In Proc. USENIX ATC, 2020

    2020

  34. [42]

    Sponge: Fast reactive scaling for stream processing with serverless frameworks

    Won Wook Song, Taegeon Um, Sameh Elnikety, Myeongjae Jeon, and Byung- Gon Chun. Sponge: Fast reactive scaling for stream processing with serverless frameworks. In 2023 USENIX Annual Technical Conference (USENIX ATC 23), 2023

    2023

  35. [43]

    Gonzalez, Joseph M

    Vikram Sreekanti, Chenggang Wu, Xiayue Charles Lin, Johann Schleier-Smith, Joseph E. Gonzalez, Joseph M. Hellerstein, and Alexey Tumanov. Cloudburst: stateful functions-as-a-service. In Proc. VLDB Endow., 2020

    2020

  36. [44]

    Frans Kaashoek

    Ariel Szekely, Adam Belay, Robert Morris, and M. Frans Kaashoek. Unifying serverless and microservice workloads with SigmaOS. In Proceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles , 2024

    2024

  37. [45]

    Sequoia: enabling quality-of-service in serverless computing

    Ali Tariq, Austin Pahl, Sharat Nimmagadda, Eric Rozner, and Siddharth Lanka. Sequoia: enabling quality-of-service in serverless computing. In Proc. ACM SoCC, 2020

    2020

  38. [46]

    Benchmarking, analysis, and optimization of serverless function snapshots

    Dmitrii Ustiugov, Plamen Petrov, Marios Kogias, Edouard Bugnion, and Boris Grot. Benchmarking, analysis, and optimization of serverless function snapshots. In Proc. ACM ASPLOS, 2021

    2021

  39. [47]

    FaaSNet: Scalable and fast provisioning of custom serverless container runtimes at alibaba cloud function compute

    Ao Wang, Shuai Chang, Huangshi Tian, Hongqi Wang, Haoran Yang, Huiba Li, Rui Du, and Yue Cheng. FaaSNet: Scalable and fast provisioning of custom serverless container runtimes at alibaba cloud function compute. InProc. USENIX ATC, 2021

    2021

  40. [48]

    Faastube: Optimizing gpu-oriented data transfer for serverless computing

    Hao Wu, Junxiao Deng, Minchen Yu, Yue Yu, Yaochen Liu, Hao Fan, Song Wu, and Wei Wang. Faastube: Optimizing gpu-oriented data transfer for serverless computing. arXiv preprint arXiv:2411.01830, 2024

    2024 arXiv

  41. [49]

    INFless: a native serverless system for low-latency, high-throughput inference

    Yanan Yang, Laiping Zhao, Yiming Li, Huanyu Zhang, Jie Li, Mingyang Zhao, Xingzhen Chen, and Keqiu Li. INFless: a native serverless system for low-latency, high-throughput inference. In Proc. ACM ASPLOS, 2022

    2022

  42. [50]

    Following the data, not the function: Rethinking function orchestration in serverless computing

    Minchen Yu, Tingjia Cao, Wei Wang, and Ruichuan Chen. Following the data, not the function: Rethinking function orchestration in serverless computing. In Proc. USENIX NSDI, 2023

    2023

  43. [51]

    Pheromone: Re- structuring serverless computing with data-centric function orchestration

    Minchen Yu, Tingjia Cao, Wei Wang, and Ruichuan Chen. Pheromone: Re- structuring serverless computing with data-centric function orchestration. IEEE Transactions on Networking, 33(1):226–240, 2025

    2025

  44. [52]

    Gillis: Serving large neural networks in serverless functions with automatic model partitioning

    Minchen Yu, Zhifeng Jiang, Hok Chun Ng, Wei Wang, Ruichuan Chen, and Bo Li. Gillis: Serving large neural networks in serverless functions with automatic model partitioning. In Proc. IEEE ICDCS, 2021

    2021

  45. [53]

    Faaswap: Slo-aware, gpu- efficient serverless inference via model swapping.arXiv preprint arXiv:2306.03622, 2024

    Minchen Yu, Ao Wang, Dong Chen, Haoxuan Yu, Xiaonan Luo, Zhuohao Li, Wei Wang, Ruichuan Chen, Dapeng Nie, and Haoran Yang. Faaswap: Slo-aware, gpu- efficient serverless inference via model swapping.arXiv preprint arXiv:2306.03622, 2024

    2024 arXiv

  46. [54]

    𝜆scale: Enabling fast scaling for serverless large language model inference.arXiv preprint arXiv:2502.09922, 2025

    Minchen Yu, Rui Yang, Chaobo Jia, Zhaoyuan Su, Sheng Yao, Tingfeng Lan, Yuchen Yang, Yue Cheng, Wei Wang, Ao Wang, and Ruichuan Chen. 𝜆scale: Enabling fast scaling for serverless large language model inference.arXiv preprint arXiv:2502.09922, 2025

    2025

  47. [55]

    MArk: Exploiting cloud services for cost-effective, SLO-aware machine learning inference serving

    Chengliang Zhang, Minchen Yu, Wei Wang, and Feng Yan. MArk: Exploiting cloud services for cost-effective, SLO-aware machine learning inference serving. In Proc. USENIX ATC, 2019

    2019

  48. [56]

    Caerus: NIMBLE task scheduling for serverless analytics

    Hong Zhang, Yupeng Tang, Anurag Khandelwal, Jingrong Chen, and Ion Stoica. Caerus: NIMBLE task scheduling for serverless analytics. In Proc. USENIX NSDI, 2021

    2021

  49. [57]

    SHEPHERD: Serving DNNs in the wild

    Hong Zhang, Yupeng Tang, Anurag Khandelwal, and Ion Stoica. SHEPHERD: Serving DNNs in the wild. In Proc. USENIX NSDI, 2023. 7

    2023

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.