Serverless Runtime Reuse Through Pointer-Switched Memory Isolation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Serverless computing in FaaS environments faces performance penalties due to the ephemeral nature of execution environments, which leads to increased latency and monetary losses, while reusing these environments risks tainting the runtime and compromising isolation.
Innovation Solution
Implement a method to reuse execution environments for serverless functions by swapping and refreshing memory associated with the code and state, ensuring isolation through pointer modification to different memory areas, thereby maintaining performance and security.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If execution environments are reused for serverless functions, then performance is improved by reducing deployment time and computational expenses, but isolation is compromised and runtime contamination risks increase
Solution Approach 1:
The patent segments the execution environment into reusable components (code, runtime) and non-reusable components (memory state). By separating these elements, the system can reuse the code and runtime across multiple function invocations while ensuring that memory state is properly isolated and refreshed for each invocation, thus maintaining both performance and isolation.
Solution Approach 2:
The patent changes the state parameters of the execution environment by refreshing memory between function invocations. This parameter change ensures that while the execution environment structure remains reusable, the memory content is reset to a clean state, preventing contamination and maintaining isolation guarantees.
2Reliability
If execution environments are provisioned on-demand for each function invocation, then isolation and stability are improved, but response time and latency increase due to provisioning delays
Solution Approach 1:
The patent performs preliminary actions by pre-provisioning execution environments and loading code into memory before function invocations occur. This allows the system to avoid on-demand provisioning delays during actual function execution, while still maintaining isolation through proper memory management and state refreshment between invocations.
Solution Approach 2:
The patent maintains continuous execution environments that remain active and ready for multiple function invocations, eliminating the stop-start nature of on-demand provisioning. This continuity reduces latency and response time while isolation is maintained through memory state management rather than environment recreation.
3Productivity
If execution environments are reused without refreshing memory, then performance is improved by eliminating deployment overhead, but runtime contamination occurs and isolation is compromised
Solution Approach 1:
The patent discards the memory state after each function invocation and recovers it by refreshing or resetting the memory to a clean state before the next invocation. This allows the execution environment structure to be reused for performance while ensuring that no residual data or state contamination persists between invocations, maintaining isolation guarantees.
Data Source
AI summary
Systems, methods, and computer-readable media are provided for reusing execution environments and code of serverless functions while ensuring isolation in serverless computing environments. In some examples, a method can include, in response to a first request to run a serverless function, executing, at an execution environment on a network, computer-readable code configured to perform the serverless function; after the computer-readable code has executed, modifying a pointer to an area of memory used to store a first state of the serverless function to reference a different area of memory; in response to a second request to run the serverless function, reusing, at the execution environment, the computer-readable code to perform the serverless function; and based on the pointer referencing the different area of memory, using the different area of memory to store a second state of the serverless function.