Pith. sign in

REVIEW 4 major objections 4 minor 60 references

CWASI: A WebAssembly Runtime Shim for Inter-function Communication in the Serverless Edge-Cloud Continuum

T0 review · 4 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read CWASI, a WebAssembly runtime shim, reduces inter-function communication latency between co-located serverless functions by up to 95% and raises throughput by up to 30x.

desk verdict A plausible, well-scoped Wasm shim for co-located serverless communication, but the headline 30x throughput claim rests on a fan-in result derived from fan-out data rather than measured. read the letter →

arxiv 2504.21503 v1 pith:YAXDPULH submitted 2025-04-30 cs.DC

Cynthia Marcelino , Stefan Nastic This is my paper · ORCID
classification cs.DC
keywords WebAssemblyserverlessfunctionsinter-functioncommunicationruntimeshimfunctionlocalityedge-cloudcontinuumUnixdomainsocket
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

CWASI is a WebAssembly runtime shim that decides how two serverless functions exchange data based on whether they run on the same machine. For co-located functions, it bypasses remote object storage and key-value stores, instead using one of three mechanisms: statically embedding trusted functions into a single WebAssembly VM, passing data through a local Unix-domain socket buffer, or, for functions on different hosts, falling back to networked message passing. The paper argues this locality-aware selection is what allows CWASI to reduce communication latency between co-located functions by up to 95% and raise throughput by up to 30x compared to existing WebAssembly and container serverless runtimes. If correct, composed serverless workflows on edge-cloud systems would no longer need remote storage round-trips for every data exchange, lowering both latency and infrastructure cost.

What carries the argument

The load-bearing mechanism is the locality-aware inter-function communication (IFC) selection: a three-mode model—Function Embedding (statically linking multiple WebAssembly modules into one VM so they share memory), Local Buffer (Unix-domain socket data exchange between shims on the same host), and Networked Buffer (publish/subscribe over the network for remote functions)—chosen at runtime by the Function Coordinator (based on OCI annotations) and the Request Dispatcher (based on container-manager state). This machinery replaces remote storage round-trips for co-located functions, directly producing the reported latency and throughput gains.

What would settle it

Run an actual fan-in experiment with many concurrent source functions sending to a single receiver function on one host and compare measured throughput and latency to the paper's derived fan-in numbers; if they differ materially, the 30x claim is not reproduced. Additionally, re-run the sequential co-located experiment with independent instrumentation to verify the 95% latency reduction.

Watch

Extended reading notes

Core claim

CWASI's central claim is that inter-function communication in WebAssembly-based serverless platforms can be optimized by exploiting function locality, and that a runtime shim can perform the mode selection transparently. The shim introduces a three-mode communication model: Function Embedding, where trusted functions from the same namespace are statically linked into a single WebAssembly VM and share memory; Local Buffer, where co-located functions in separate sandboxes exchange data through a Unix-domain socket in the host kernel; and Networked Buffer, which uses publish/subscribe messaging for remote functions. During startup and at runtime, the Function Coordinator and Request Dispatcher components read OCI annotations and container-manager state to pick a mode. The paper reports that in sequential, fan-out, and (derived) fan-in workflow measurements, CWASI lowers latency by up to 95% and raises throughput by up to 30x relative to the WasmEdge and OpenFaaS baselines.

Load-bearing premise

The fan-in performance numbers in the paper are not measured; they are calculated from the fan-out experiments, so the 30x throughput claim depends on the assumption that a fan-in workflow's timing mirrors a fan-out workflow.

Editorial extensions

If this is right

  • Co-located serverless workflows in edge-cloud deployments can bypass remote object storage and key-value stores for inter-function data exchange, reducing per-request latency and network overhead.
  • The mode selection is transparent to the functions: the same function interface works, but data moves through host memory or Unix sockets instead of the network when functions share a host.
  • In fan-out and derived fan-in patterns, CWASI sustains hundreds of requests per second on a single host, up to 30x the throughput of a plain WebAssembly runtime.
  • Sequential workflows pay no extra resource penalty: RAM usage drops by up to 30% versus WasmEdge and up to 15% versus OpenFaaS in the reported measurements.
  • Because the shim is OCI-compliant, it can slot into existing container-manager-based serverless stacks without changing the deployment model.

Reading between the lines

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

  • A true fan-in experiment (many concurrent senders, one receiver) may expose contention that the paper's derived fan-in numbers miss; the 30x throughput headline should be re-tested with an actual fan-in workload before being taken at face value.
  • The same locality-aware dispatch idea could generalize to non-WebAssembly serverless runtimes: any shim with access to container-manager state could route co-located traffic through local IPC, though the paper only evaluates Wasm.
  • Function Embedding trades isolation for speed (shared address space for trusted functions); for multi-tenant edges, that trust assumption is the crux, and the paper's future work on programming models might let deployments express trust boundaries automatically.
  • If the derived fan-in numbers do hold, CWASI makes high-frequency fan-in aggregations (e.g., many frame processors reducing into one dataset builder) practical on a single node, reducing reliance on cloud-side aggregation services.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper presents CWASI, a container runtime shim for WebAssembly serverless functions that selects among three inter-function communication modes (Function Embedding, Local Buffer via Unix domain sockets, and Networked Buffer via Redis Pub/Sub) based on function locality and trust. The claimed benefit is reduced latency and increased throughput for co-located serverless functions. The authors evaluate CWASI against WasmEdge RunWasi shim and OpenFaaS across sequential, fan-out, and fan-in workflow patterns, measuring latency, throughput, CPU, and RAM, and report up to 95% latency reduction and up to 30x throughput improvement.

Significance. If the reported gains hold, CWASI would reduce reliance on remote storage and messaging for co-located serverless functions, lowering end-to-end latency and improving data-plane scalability in edge-cloud workflows. The paper contributes a concrete OCI-compliant shim design, pseudocode for mode selection, and an open-source implementation link, which are strengths for reproducibility. The direct sequential and fan-out measurements appear to support large latency gains, and the fan-out throughput gains versus WasmEdge are directly measured. The headline 30x throughput claim, however, rests on fan-in numbers that were not actually measured, and the throughput methodology itself needs clarification. The central idea is solid but the evidence for the strongest claim is incomplete.

major comments (4)
  1. [Section 7.5 (Fan-in Workflow) and Table 2] The fan-in results in Table 2 are not measurements. Section 7.5 states: 'we use the fan-out experiments and calculate the responses, revealing a fan-in workflow.' The abstract and conclusion base the 'up to 30x' throughput claim on the Fan-in row (CWASI 314.2 req/s vs WasmEdge 8.53 req/s). A fan-in workload with concurrent callers contending on a single receiver introduces accept-queue contention and a potential receiver bottleneck that fan-out measurements cannot capture. Please either run a real fan-in experiment with multiple concurrent callers and report measured values, or remove or qualify the 30x claim.
  2. [Section 7.5 (Fan-in Workflow)] The paper's own description of the fan-in proxy is internally inconsistent. It states that if a function is called ten times, CWASI creates ten different functions, 'which means fan-in is the same as ten different sequential workflows.' That is not fan-in; fan-in requires multiple callers to the same receiver. Moreover, the calculation that transforms the fan-out measurements into the Table 2 fan-in numbers is undocumented: the fan-in latency and throughput values (0.0029/0.0032 s, 298.95/314.20 req/s) differ from the fan-out values (0.0045/0.0066 s, 203.73/211.20 req/s), so this is not a trivial reuse of the same data. A derivation of the calculation or, preferably, an actual measurement is needed.
  3. [Section 7.1 (Metrics, Throughput)] The throughput measurement procedure is not a standard sustained-load measurement. The paper says: 'In cases where the executions are lower than one second, we extrapolate, e.g., if we send ten requests that take less than one second, we extrapolate the throughput by considering the rate of execution over a one-second timeframe.' This appears to derive throughput from per-request latency rather than from the number of requests completed under concurrency per unit time. Since the headline claim is about throughput, please describe the load generator, the concurrency level, and the measurement duration, and report throughput as measured under load.
  4. [Section 7.2 (Experiment Setup)] No variance is reported. The setup says experiments were repeated ten times and the average collected, but no standard deviation, confidence interval, or per-run values are given. Without variance, the reader cannot assess whether the smaller reported differences, such as the 1.3x throughput advantage over OpenFaaS in fan-out, are significant. Please include error bars or a statistical summary for the key tables.
minor comments (4)
  1. [Section 6 (Implementation)] The sentence 'It is implemented in Rust and currently supports WasmEdge runtime. source code is available on GitHub' is duplicated word-for-word; remove the duplicate.
  2. [Keywords] 'WebAssemly' is misspelled; it should be 'WebAssembly'.
  3. [Section 7.4 (Fan-out Workflow)] The text says 'CWASI shows around 3 ms, WasmEdge 115 ms, and OpenFaas 7 ms' and repeats this as 'According to Table 2', but the Fan-out rows in Table 2 list 0.0045/0.0066 s for CWASI and 0.1931/0.1950 s for WasmEdge. Please make the text consistent with the table.
  4. [Section 7.5 (Fan-in Workflow)] The opening sentence references 'as shown in Section 7.5' but the fan-in pattern is shown in Fig. 6c; correct the cross-reference.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the reported latency/throughput gains are empirical comparisons against external baselines, and the fan-in proxy is a validity limitation rather than a self-referential derivation.

full rationale

CWASI makes no mathematical derivation and fits no parameters; its claims are experimental numbers measured against external baselines, WasmEdge and OpenFaaS. The only place a result is derived from another result rather than directly executed is Section 7.5, where the fan-in numbers are calculated from the fan-out experiments as an explicitly acknowledged workaround. That could undermine the 30x throughput headline if a true fan-in workload behaves differently, but it is not circularity: the fan-out data are not defined in terms of the fan-in claim, no fitted parameter is renamed as a prediction, and no load-bearing argument reduces to a self-citation. Self-citations in related work, such as the authors' earlier serverless fabric and edge-computing surveys, are contextual and do not determine the experimental outcome. The evaluation is self-contained against external baselines, so the circularity score is 0.

Assumptions & free parameters 0 free parameters · 2 assumptions · 0 invented entities

No new physical or mathematical entities are introduced. The three-mode communication model is a software design, not an invented entity. The evaluation uses no fitted parameters; the only assumptions are domain assumptions about trust and WasmEdge's static-linking capability.

assumptions (2)
  • domain assumption Functions that belong to the same namespace are fully trusted and may share one sandbox, so reducing isolation is acceptable.
    Section 4.1 states Function Embedding decreases function isolation but considers same-namespace functions trusted. The first mode of the communication model depends on this trust assumption.
  • domain assumption Wasm static linking can be performed at runtime by the host shim (WasmEdge) for arbitrary modules found in the container manager snapshot.
    Section 5.1 and Algorithm 3 assume imports in the WAT file can be matched to host bundles and linked before VM start. This is an external tooling capability the paper relies on without demonstrating for arbitrary modules.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CWASI: A WebAssembly Runtime Shim for Inter-function Communication in the Serverless Edge-Cloud Continuum." pith.science (2026). https://pith.science/paper/YAXDPULH

@misc{pith2026250421503,
  author       = {Pith},
  title        = {Pith review of: CWASI: A WebAssembly Runtime Shim for Inter-function Communication in the Serverless Edge-Cloud Continuum},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YAXDPULH}},
  note         = {Machine review of arXiv:2504.21503}
}
read the original abstract

Serverless Computing brings advantages to the Edge-Cloud continuum, like simplified programming and infrastructure management. In composed workflows, where serverless functions need to exchange data constantly, serverless platforms rely on remote services such as object storage and key-value stores as a common approach to exchange data. In WebAssembly, functions leverage WebAssembly System Interface to connect to the network and exchange data via remote services. As a consequence, co-located serverless functions need remote services to exchange data, increasing latency and adding network overhead. To mitigate this problem, in this paper, we introduce CWASI: a WebAssembly OCI-compliant runtime shim that determines the best inter-function data exchange approach based on the serverless function locality. CWASI introduces a three-mode communication model for the Serverless Edge-Cloud continuum. This communication model enables CWASI Shim to optimize inter-function communication for co-located functions by leveraging the function host mechanisms. Experimental results show that CWASI reduces the communication latency between the co-located serverless functions by up to 95% and increases the communication throughput by up to 30x.

Figures

Figures reproduced from arXiv: 2504.21503 by the authors.

Figure 1
Figure 1. Serverless Workflow for Image Processing for [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Overview of Edge-Cloud Serverless Platforms [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. CWASI Inter-function Communication Model [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: shows CWASI core components: Function Coordinator and Request Dispatcher. These core components implement the following features: (i) Function (Fn) Lifecycle; (ii) Function Embedding (FE) Discovery;(iii) Local Buffer (LB) Receiver;(iv)Network (N) Receiver; (v) Inter-Fu…
Figure 5
Figure 5. Figure 5: Local Buffer Inter-function Communication [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: a shows an example of a Sequential workflow when only one instance of Extract Frames, Process Frames, and Prepare Dataset is created, so each function is called sequentially. A Fan-out workflow, shown in Fig. 6b, happens when one function triggers multiple parallel fun…
Figure 7
Figure 7. Figure 7: Sequential Results 1  1      1 11          (a) Latency 1  1      11 1        (b) Throughput 1 1   [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Fan-out Results 1  1      1 1 11 [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 9
Figure 9. Figure 9: Fan-in Results in orange is due to resource usage already discussed in Section 7.4. According to Fig. 9a and [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

60 extracted references · 38 canonical work pages

  1. [1]

    Towards a serverless platform for edge computing

    Luciano Baresi and Danilo Filgueira Mendonça. Towards a serverless platform for edge computing. In2019 IEEE International Conference on Fog Computing (ICFC), pages 1–10, 2019. doi: 10.1109/ICFC.2019.00008

    arXiv 2019

  2. [2]

    Hellerstein, Jose Faleiro, Joseph E

    Joseph M. Hellerstein, Jose Faleiro, Joseph E. Gonzalez, Johann Schleier-Smith, Vikram Sreekanti, Alexey Tumanov, and Chenggang Wu. Serverless computing: One step forward, two steps back, 2018

    work page 2018

  3. [3]

    Challenges and opportunities for efficient serverless computing at the edge

    Phani Kishore Gadepalli, Gregor Peach, Ludmila Cherkasova, Rob Aitken, and Gabriel Parmer. Challenges and opportunities for efficient serverless computing at the edge. In2019 38th Symposium on Reliable Distributed Systems (SRDS), pages 261–2615, 2019. doi: 10.1109/SRDS47363.2019.00036

    work page arXiv 2019

  4. [4]

    Bringing the web up to speed with webassembly.SIGPLAN Not., 52(6):185–200, jun 2017

    AndreasHaas,AndreasRossberg,DerekL.Schuff,BenL.Titzer,MichaelHolman, Dan Gohman, Luke Wagner, Alon Zakai, and JF Bastien. Bringing the web up to speed with webassembly.SIGPLAN Not., 52(6):185–200, jun 2017. ISSN 0362-

    work page 2017

  5. [5]

    pages 140–149, 05 2022

    PhilippGackstatter,PantelisFrangoudis,andSchahramDustdar.Pushingserverless to the edge with webassembly runtimes. pages 140–149, 05 2022. doi: 10.1109/ CCGrid54584.2022.00023

    arXiv 2022

  6. [6]

    A serverless computing fabric for edge & cloud

    Stefan Nastic, Philipp Raith, Alireza Furutanpey, Thomas Pusztai, and Schahram Dustdar. A serverless computing fabric for edge & cloud. In2022 IEEE 4th International Conference on Cognitive Machine Intelligence (CogMI), pages 1–12,

    work page

  7. [7]

    doi: 10.1109/TSC.2021.3128137

    Sasko Ristov, Stefan Pedratscher, and Thomas Fahringer.𝑥𝑎𝑓 𝑐𝑙 xafcl: Run scalable function choreographies across multiple faas systems.IEEE Transactions on Services Computing, 16(1):711–723, 2023. doi: 10.1109/TSC.2021.3128137

    arXiv 2023

  8. [8]

    Faleiro, Yihan Lin, and Joseph M

    Chenggang Wu, Jose M. Faleiro, Yihan Lin, and Joseph M. Hellerstein. Anna: A kvs for any scale.2018 IEEE 34th International Conference on Data Engineering (ICDE), pages 401–412, 2018

    work page 2018

Show all 60 references
  1. [9]

    Faleiro, Joseph E

    Vikram Sreekanti, Chenggang Wu, Xiayue Charles Lin, Johann Schleier-Smith, Jose M. Faleiro, Joseph E. Gonzalez, Joseph M. Hellerstein, and Alexey Tumanov. Cloudburst: Stateful functions-as-a-service.Proc. VLDB Endow., 13:2438–2452, 2020

    2020

  2. [10]

    Jiffy: Elastic far-memory for stateful serverless analytics

    AnuragKhandelwal,YupengTang,RachitAgarwal, Aditya Akella, andIon Stoica. Jiffy: Elastic far-memory for stateful serverless analytics. InProceedings of the Seventeenth European Conference on Computer Systems, EuroSys ’22, page 697–713, New York, NY, USA, 2022. Association for C...

    2022

  3. [11]

    Eismann, J

    S. Eismann, J. Scheuner, E. van Eyk, M. Schwinger, J. Grohmann, N. Herbst, C. L. Abad,andA.Iosup. Serverlessapplications:Why,when,andhow? IEEESoftware, 38(01):32–39, jan 2021. ISSN 1937-4194. doi: 10.1109/MS.2020.3023302

    2021

  4. [12]

    Papaioannou, Nicolas Bonvin, and Karl Aberer

    Thanasis G. Papaioannou, Nicolas Bonvin, and Karl Aberer. Scalia: An adaptive schemeforefficientmulti-cloudstorage.In SC’12:ProceedingsoftheInternational Conference on High Performance Computing, Networking, Storage and Analysis, pages 1–10, 2012. doi: 10.1109/SC.2012.101

    2012 doi

  5. [13]

    An adaptive data placement architecture in multicloud environments.Sci

    Pengwei Wang, Caihui Zhao, Yi Wei, Dong Wang, and Zhaohui Zhang. An adaptive data placement architecture in multicloud environments.Sci. Program., 2020:1704258:1–1704258:12, 2020

    2020

  6. [14]

    Wasi, 2023

    Bytecode Alliance. Wasi, 2023. URL https://wasi.dev

    2023

  7. [15]

    Floki: A proactive data forwarding system for direct inter-function communication for serverless workflows

    Anna Maria Nestorov, Josep Lluís Berral, Claudia Misale, Chen Wang, David Carrera, and Alaa Youssef. Floki: A proactive data forwarding system for direct inter-function communication for serverless workflows. InProceedings of the Eighth International Workshop on Container Tech...

    2022

  8. [16]

    Serverless edge comput- ing—where we are and what lies ahead.IEEE Internet Computing, 27(3):50–64,

    Philipp Raith, Stefan Nastic, and Schahram Dustdar. Serverless edge comput- ing—where we are and what lies ahead.IEEE Internet Computing, 27(3):50–64,

  9. [17]

    SAND:TowardsHigh-Performance serverless computing

    Istemi Ekin Akkus, Ruichuan Chen, Ivica Rimac, Manuel Stein, Klaus Satzke, AndreBeck,PaarijaatAditya,andVolkerHilt. SAND:TowardsHigh-Performance serverless computing. In2018 USENIX Annual Technical Conference (USENIX ATC 18), pages 923–935, Boston, MA, July 2018. USENIX Associa...

    2018

  10. [18]

    Process-as-a-Service: FaaSt Stateful Computing with Optimized Data Planes

    MarcinCopik,AlexandruCalotoiu,RodrigoBruno,RomanBöhringer,andTorsten Hoefler. Process-as-a-Service: FaaSt Stateful Computing with Optimized Data Planes. Technical report, 01 2022

    2022

  11. [19]

    FreeFlow: Software-based virtual RDMA networking for containerized clouds

    Daehyeok Kim, Tianlong Yu, Hongqiang Harry Liu, Yibo Zhu, Jitu Padhye, Shachar Raindel, Chuanxiong Guo, Vyas Sekar, and Srinivasan Seshan. FreeFlow: Software-based virtual RDMA networking for containerized clouds. In16th USENIXSymposiumonNetworkedSystemsDesignandImplementation...

    2019

  12. [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. InProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS ’21,...

    2021

  13. [21]

    Faastlane: Accelerating Function-as-a-Service workflows

    Swaroop Kotni, Ajay Nayak, Vinod Ganapathy, and Arkaprava Basu. Faastlane: Accelerating Function-as-a-Service workflows. In2021 USENIX Annual Techni- cal Conference (USENIX ATC 21), pages 805–820. USENIX Association, July

  14. [22]

    Faasm: Lightweight isolation for efficient stateful serverless computing

    Simon Shillaker and Peter Pietzuch. Faasm: Lightweight isolation for efficient stateful serverless computing. In2020 USENIX Annual Technical Conference (USENIX ATC 20), pages 419–433. USENIX Association, July 2020. ISBN 978-1-939133-14-4. URL https://www.usenix.org/conference/...

    2020

  15. [23]

    Faabric: Fine-grained distribution of scientific workloads in the cloud.arXiv preprint arXiv:2302.11358, 2023

    Simon Shillaker, Carlos Segarra, Eleftheria Mappoura, Mayeul Fournial, Lluis Vilanova, and Peter Pietzuch. Faabric: Fine-grained distribution of scientific workloads in the cloud.arXiv preprint arXiv:2302.11358, 2023

    2023 arXiv

  16. [24]

    Pipedevice: A hardware-software co-design approach to intra-host container communication

    QiangSu,ChuanwenWang,ZhixiongNiu,RanShu,PengCheng,YongqiangXiong, Dongsu Han, Chun Jason Xue, and Hong Xu. Pipedevice: A hardware-software co-design approach to intra-host container communication. InProceedings of the 18th International Conference on Emerging Networking EXperi...

    2022

  17. [25]

    How and why to link webassembly modules,

    Linux Foundation. How and why to link webassembly modules,

  18. [26]

    Field notes: Building an automated image process- ing and model training pipeline for autonomous driving, 2021

    AWS Amazon. Field notes: Building an automated image process- ing and model training pipeline for autonomous driving, 2021. URL https://aws.amazon.com/blogs/architecture/field-notes-building-an-automated- image-processing-and-model-training-pipeline-for-autonomous-driving/

    2021

  19. [27]

    React: Streaming video analytics on the edge with asynchronous cloud support

    Anurag Ghosh, Srinivasan Iyengar, Stephen Lee, Anuj Rathore, and Venkata N Padmanabhan. React: Streaming video analytics on the edge with asynchronous cloud support. InProceedings of the 8th ACM/IEEE Conference on Internet of Things Design and Implementation, IoTDI ’23, page 2...

    2023

  20. [28]

    Serverless empowered video analytics for ubiquitous networked cameras.IEEE Network, 35 (6):186–193, 2021

    Miao Zhang, Fangxin Wang, Yifei Zhu, Jiangchuan Liu, and Bo Li. Serverless empowered video analytics for ubiquitous networked cameras.IEEE Network, 35 (6):186–193, 2021. doi: 10.1109/MNET.101.2000668

    2021 doi

  21. [29]

    In11th USENIX Workshop on Hot Topics in Cloud Computing (HotCloud 19), Renton, WA, July 2019.USENIXAssociation

    YidingWang,WeiyanWang,JunxueZhang,JunchenJiang,andKaiChen.Bridging the Edge-Cloud barrier for real-time advanced vision analytics. In11th USENIX Workshop on Hot Topics in Cloud Computing (HotCloud 19), Renton, WA, July 2019.USENIXAssociation. URLhttps://www.usenix.org/conferen...

    2019

  22. [30]

    URL https://training.linuxfoundation.org/blog/how-and-why-to-link- webassembly-modules/

  23. [31]

    Runwasi, 2023

    Containerd. Runwasi, 2023. URL https://github.com/containerd/runwasi

    2023

  24. [32]

    Garrett McGrath and Paul R. Brenner. Serverless computing: Design, imple- mentation, and performance. In2017 IEEE 37th International Conference on Distributed Computing Systems Workshops (ICDCSW), pages 405–410, 2017. doi: 10.1109/ICDCSW.2017.36

    2017 doi

  25. [33]

    Open-source serverless architectures: an evaluation of apache openwhisk

    Karim Djemame, Matthew Parker, and Daniel Datsev. Open-source serverless architectures: an evaluation of apache openwhisk. In2020 IEEE/ACM 13th International Conference on Utility and Cloud Computing (UCC), pages 329–335,

  26. [34]

    Performance analysis between runc and kata container runtime

    Rakesh Kumar and B Thangaraju. Performance analysis between runc and kata container runtime. In2020 IEEE International Conference on Electronics, Computing and Communication Technologies (CONECCT), pages 1–4. IEEE, 2020

    2020

  27. [35]

    Sledge: A serverless-first, light-weight wasm runtime for the edge

    Phani Kishore Gadepalli, Sean McBride, Gregor Peach, Ludmila Cherkasova, and Gabriel Parmer. Sledge: A serverless-first, light-weight wasm runtime for the edge. In Proceedings of the 21st International Middleware Conference, Middleware ’20, page 265–279, New York, NY, USA, 202...

    2020

  28. [36]

    Kata containers: An emerging architecture for enabling mec services in fast and secure way

    Alessandro Randazzo and Ilenia Tinnirello. Kata containers: An emerging architecture for enabling mec services in fast and secure way. In2019 Sixth InternationalConferenceonInternetofThings:Systems,ManagementandSecurity (IOTSMS), pages 209–214. IEEE, 2019

    2019

  29. [37]

    Serverless functions, made simple, 2023

    OpenFaaS. Serverless functions, made simple, 2023. URL https://www.openfaas. com

    2023

  30. [38]

    An evaluation of webassembly in non-web environments

    Benedikt Spies and Markus Mock. An evaluation of webassembly in non-web environments. In 2021 XLVII Latin American Computing Conference (CLEI), pages 1–10, 2021. doi: 10.1109/CLEI53233.2021.9640153

    2021

  31. [39]

    Wasmtime, 2023

    Bytecode Alliance. Wasmtime, 2023. URL https://wasmtime.dev

    2023

  32. [40]

    Salim, Andy Nisbet, and Mikel Luján

    Salim S. Salim, Andy Nisbet, and Mikel Luján. Trufflewasm: A webassembly interpreter on graalvm. InProceedings of the 16th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments, VEE ’20, page 88–100,NewYork,NY,USA,2020.AssociationforComputingMachinery. ...

    2020

  33. [41]

    Kulkarni, K

    Junfeng Li, Sameer G. Kulkarni, K. K. Ramakrishnan, and Dan Li. Understanding open source serverless platforms: Design considerations and performance. In Proceedings of the 5th International Workshop on Serverless Computing, WOSC ’19,page37–42,NewYork,NY,USA,2019.Associationfo...

    2019

  34. [42]

    Evaluatingwebassem- bly for orchestrated deployment of serverless functions

    VojdanKjorveziroski,SonjaFiliposka,andAnastasMishev. Evaluatingwebassem- bly for orchestrated deployment of serverless functions. In2022 30th Telecommu- nications Forum (TELFOR), pages 1–4, 2022. doi: 10.1109/TELFOR56187.2022. 9983733

    2022

  35. [43]

    A lightweight designforserverlessfunctionasaservice

    Ju Long, Hung-Ying Tai, Shen-Ta Hsieh, and Michael Juntao Yuan. A lightweight designforserverlessfunctionasaservice. IEEESoftware,38(1):75–80,2021. doi: 10.1109/MS.2020.3028991

    2021

  36. [44]

    Opencontainerinitiativeruntimespecification,2023

    TheLinuxFoundation. Opencontainerinitiativeruntimespecification,2023. URL https://github.com/opencontainers/runtime-spec/blob/main/spec.md

    2023

  37. [45]

    SOCK:Rapidtaskprovisioningwith Serverless-Optimized containers

    Edward Oakes, Leon Yang, Dennis Zhou, Kevin Houck, Tyler Harter, Andrea Arpaci-Dusseau,andRemziArpaci-Dusseau. SOCK:Rapidtaskprovisioningwith Serverless-Optimized containers. In2018 USENIX Annual Technical Conference (USENIX ATC 18), pages 57–70, Boston, MA, July 2018. USENIX ...

    2018

  38. [46]

    In2021 USENIX Annual Technical Conference (USENIX ATC 21), pages285–301.USENIXAssociation,July2021

    AshrafMahgoub,KarthickShankar,SubrataMitra,AnaKlimovic,SomaliChaterji, andSaurabhBagchi.SONIC:Application-awaredatapassingforchainedserverless applications. In2021 USENIX Annual Technical Conference (USENIX ATC 21), pages285–301.USENIXAssociation,July2021. ISBN978-1-939133-23-...

  39. [47]

    Weakeningwebassem- bly

    ConradWatt,AndreasRossberg,andJeanPichon-Pharabod. Weakeningwebassem- bly. Proc. ACM Program. Lang., 3(OOPSLA), oct 2019. doi: 10.1145/3360559. URL https://doi.org/10.1145/3360559

    2019 doi

  40. [48]

    Pocket: Ml serving from the edge

    Misun Park, Ketan Bhardwaj, and Ada Gavrilovska. Pocket: Ml serving from the edge. InProceedings of the Eighteenth European Conference on Computer Systems, EuroSys ’23, page 46–62, New York, NY, USA, 2023. Association for Computing Machinery. ISBN 9781450394871. doi: 10.1145/3...

    2023

  41. [49]

    Wasmedge, 2023

    Wasmedge. Wasmedge, 2023. URL https://wasmedge.org

    2023

  42. [50]

    No Starch Press, USA, 1st edition, 2010

    Michael Kerrisk.The Linux Programming Interface: A Linux and UNIX System Programming Handbook. No Starch Press, USA, 1st edition, 2010. ISBN 1593272200

    2010

  43. [51]

    Webassembly specification, 2023

    W3C Community Group. Webassembly specification, 2023. URL https: //webassembly.github.io/spec/core/index.html

    2023

  44. [52]

    Gonzalez, Raluca Ada Popa, Ion Stoica, and David A

    Eric Jonas, Johann Schleier-Smith, Vikram Sreekanti, Chia-Che Tsai, Anurag Khandelwal, Qifan Pu, Vaishaal Shankar, Joao Carreira, Karl Krauth, Neeraja Yad- wadkar, Joseph E. Gonzalez, Raluca Ada Popa, Ion Stoica, and David A. Patterson. Cloud programming simplified: A berkeley...

    2019

  45. [53]

    Wahby, Brennan Shacklett, Karthikeyan Vasuki Balasub- ramaniam, William Zeng, Rahul Bhalerao, Anirudh Sivaraman, George Porter, and Keith Winstein

    Sadjad Fouladi, Riad S. Wahby, Brennan Shacklett, Karthikeyan Vasuki Balasub- ramaniam, William Zeng, Rahul Bhalerao, Anirudh Sivaraman, George Porter, and Keith Winstein. Encoding, fast and slow: Low-Latency video processing using thousands of tiny threads. In14th USENIX Symp...

    2017

  46. [54]

    Multi-threading and atomics, 2020

    WebAssembly. Multi-threading and atomics, 2020. URL https://github.com/ WebAssembly/WASI/issues/296. 13

    2020

  47. [59]

    Characterizing serverless platforms with serverlessbench

    Tianyi Yu, Qingyuan Liu, Dong Du, Yubin Xia, Binyu Zang, Ziqian Lu, Pingchao Yang, Chenggang Qin, and Haibo Chen. Characterizing serverless platforms with serverlessbench. InProceedings of the 11th ACM Symposium on Cloud Computing, SoCC ’20, page 30–44, New York, NY, USA, 2020...

    2020

  48. [1340]

    URL https://doi.org/10.1145/3140587

    doi: 10.1145/3140587.3062363. URL https://doi.org/10.1145/3140587. 3062363

  49. [2020]

    doi: 10.1109/UCC48980.2020.00052

    2020

  50. [2021]

    URL https://www.usenix.org/conference/atc21/ presentation/kotni

    ISBN 978-1-939133-23-6. URL https://www.usenix.org/conference/atc21/ presentation/kotni

  51. [2022]

    doi: 10.1109/CogMI56440.2022.00011

    2022

  52. [2023]

    doi: 10.1109/MIC.2023.3260939

    2023

Pith tools

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