Prebaking runtime environments to improve the FaaS cold start latency

Abstract

Function-as-service (FaaS) platforms promise a simpler programming model for cloud computing, given that providers take care of the overall resource management while the developers can concentrate only on writing their applications in the scope of a function, not having to care about installing or scaling resources. As FaaS users are billed based on the execution of the functions, platform providers have a natural incentive not to keep idle resources running at the platform’s expense. However, this strategy may lead to the cold start issue, in which the execution of a function is delayed because there are no ready resources to host the execution. Despite the time to provision the computational resources, starting the runtime environment that manages the function execution can take hundreds of milliseconds to seconds, a prohibitive non-deterministic overhead to latency-critical applications. This work describes a practical technique, Prebaking, to reduce the function start-up time based on restoring snapshots of previously executed processes. The foundation of the Prebaking technique is that deciding when to create a snapshot of a function is essential. For example, based on a prototype we developed using the CRIU checkpoint/restore Linux tool, the performance improvement on the start-up of a properly snapshotted function is up to 25 times. Fortunately, generating a good function snapshot is easy: One only needs to checkpoint a warm function, that is, a function that has processed a request. To show the feasibility of using the Prebaking technique, we discussed integrating it into OpenFaaS, an open-source FaaS platform, including how to generate and restore function snapshots. We also evaluated our prototype by running a comprehensive set of experiments that compare the function start-up duration and cold start latency against the standard fork-exec procedure. We analyze the JVM, CPython, and Node.js runtimes. The results indicate that the technique can improve the function replica start-up time even for no-warmed functions: we improved the function replica start-up time from 3.5 times for a “do-nothing” function running in Node.js up to 12 times when considering an Image Resizer function running in CPython. Finally, we reinforce the practicability of the proposed technique by comparing our proposal to another snapshot-based technique called SEUSS. That evaluation shows that Prebaking provides better cold start latency even for slightly complex functions like the Markdown Renderer.