Towards Energy-Efficient Serverless Computing with Hardware Isolation

TL;DR

This work identifies energy-inefficiency in conventional serverless platforms arising from software-based isolation on shared hardware and overprovisioned idle capacity. It proposes a hardware-centric model where each function executes on a dedicated small computer (e.g., an SoC) that boots into the function environment, runs, and then shuts down, eliminating sandbox overhead and idle power. Through a combination of workload simulations and a preliminary hardware prototype, the authors show a potential energy reduction on the order of 90% for excess energy, with data-center-scale extrapolations suggesting large overall savings. While promising, the approach invites further investigation into datacenter integration, boot-time optimizations, and the environmental implications of deploying SoCs at scale, as well as exploring unikernel deployment to further reduce abstraction overhead and idle power.

Abstract

Serverless computing provides just-in-time infrastructure provisioning with rapid elasticity and a finely-grained pricing model. As full control of resource allocation is in the hands of the cloud provider and applications only consume resources when they actually perform work, we believe that serverless computing is uniquely positioned to maximize energy efficiency. However, the focus of current serverless platforms is to run hundreds or thousands of serverless functions from different tenants on traditional server hardware, requiring expensive software isolation mechanisms and a high degree of overprovisioning, i.e., idle servers, to anticipate load spikes. With shared caches, high clock frequencies, and many-core architectures, servers today are optimized for large, singular workloads but not to run thousands of isolated functions. We propose rethinking the serverless hardware architecture to align it with the requirements of serverless software. Specifically, we propose using hardware isolation with individual processors per function instead of software isolation resulting in a serverless hardware stack that consumes energy only when an application actually performs work. In preliminary evaluation with real hardware and a typical serverless workload we find that this could reduce energy consumption overheads by 90.63% or an average 70.8MW.

Figures (6)

• Figure 1: Traditional cloud serverless platforms use software-level isolation, e.g., using µVMs, on top of shared hardware built to make many cores or servers appear as a singular computer (\ref{['fig:lambda:old']}). We propose running functions in a one-to-one relationship on isolated, much smaller computers to decrease energy overheads (\ref{['fig:lambda:new']}).
• Figure 2: The lifecycle of our proposed approach: A manager sends the function invocation (including possible input parameters) to an available worker SoC. This worker boots from an environment for this particular function and executes that function. If necessary, the result of the execution can be sent back to the manager. As soon as the function has ended, the worker shuts down.
• Figure 3: Number of function instances, or workers, across all 200 functions in the workload trace over the course of 24$\,$h. Periodic workload spikes leave unused idle workers that block resources. The dashed line indicates the minimum capacity required in the serverless infrastructure to handle all events at the same service level.
• Figure 4: Energy requirements per µVM start are highest for a single µVM (335.81$\,$J, outside the area of the graph), as most server cores remain idle. Starting µVMs is most efficient when booting 24 to 48 µVMs concurrently, or between one and two per physical core. Still, energy use per µVM start is high at a minimum 17.98$\,$J.
• Figure 5: 100 repetitions of booting our SoC into a lightweight Linux environment show stable energy use of a mean 1.83$\,$J per boot. This is an order of magnitude smaller than booting a µVM on our server.