Hypervisor JIT Compilation Shared Memory
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional Just-in-Time (JIT) compilation in cloud-based applications leads to increased resource consumption and performance degradation due to the need for time-consuming runtime translation and duplicate executable instances, even for identical programs running on the same platform.
Innovation Solution
A cloud-based JIT-translation system that utilizes a shared memory area and signature repository to store and retrieve platform-specific executable versions of applications, allowing multiple users to access a single instance without recompiling, thereby reducing resource usage and improving performance.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of time
If JIT compilation is used to defer full compilation to runtime, then initial compilation efficiency is improved and disk space is reduced, but runtime performance deteriorates due to time-consuming translation tasks
Solution Approach 1:
The system performs preliminary JIT translation for the first user requesting an application, generating executable code in advance. This preliminary action stores the translated code in shared memory, so subsequent users can directly access pre-translated code without undergoing the time-consuming translation process, thus improving runtime performance while maintaining the deferred compilation benefit
Solution Approach 2:
The patent merges multiple user instances into a single shared executable instance in memory. By combining the translation results and runtime execution environment into one shared instance that multiple users can access simultaneously, the system eliminates redundant translation tasks and improves overall runtime efficiency
2Adaptability or versatility
If JIT translation is performed for each user instance, then individual user requirements are met, but memory consumption increases due to duplicate executable instances
Solution Approach 1:
The system merges multiple user instances into a single shared executable instance in memory. The first user instance undergoes full JIT translation and creates a shared executable image that subsequent users can access. This merging approach maintains user-specific execution capabilities while dramatically reducing memory consumption by eliminating duplicate copies of the same executable code
Solution Approach 2:
The shared executable instance serves multiple users simultaneously, making it a universal resource. The single instantiated executable code in shared memory can be accessed and executed by multiple users, allowing the same physical instance to fulfill multiple user requests and thereby reducing overall memory requirements
3Productivity
If multiple instances of the same application are launched, then user demand is satisfied, but resource consumption multiplies due to duplicate translations and executable copies
Solution Approach 1:
The system performs the resource-intensive JIT translation as a preliminary action for the first user, storing the result in shared memory. When additional users request the same application, the preliminary translation work has already been completed, so the system can quickly allocate the pre-translated executable without repeating the costly translation process, thus satisfying user demand while avoiding multiplied resource consumption
Solution Approach 2:
Instead of creating full duplicate copies of executable instances for each user, the system creates lightweight references or pointers to the single shared executable instance. This copying approach allows multiple users to access the same executable code without duplicating the actual executable memory, thereby maintaining application launch capability while dramatically reducing resource usage
Data Source
AI summary
Systems and methods improve performance and resource-efficiency of Just-in-Time (JIT) compilation in a hypervisor-based virtualized computing environment. A user attempts to launch an application that has been previously compiled by a JIT compiler into an intermediate, platform-independent format. A JIT accelerator selects a unique function signature that identifies the application and the user's target platform. If the signature cannot be found in a repository, indicating that the application has never been run on the target platform, the accelerator generates and stores the requested executable program in shared memory and saves the signature in the repository. The system then returns to the user a pointer to the stored platform-specific executable. If multiple users of the same platform request the same application, the system recognizes an affinity among those requests identified by their shared signature, and provides each user a pointer to the same previously stored, shared executable.