JVM Resource Volatility Synchronization in Hypervisors
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Server virtualization with Java Virtual Machines (JVMs) experiences high resource usage volatility due to garbage collection and code optimization, leading to larger safety margins and reduced virtualization savings compared to other server applications.
Innovation Solution
A system and method for synchronizing transient resource usage between JVMs by advancing or postponing garbage collection and code optimization processes, using a synchronization module to minimize overlaps and reduce peak resource usage volatility, with the option to move virtual servers between computers to optimize resource allocation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If JVMs perform garbage collection and code optimization independently, then each JVM can manage its own resources autonomously, but resource usage volatility increases and safety margins must be enlarged
Solution Approach 1:
The patent merges the independent resource management of multiple JVMs into a coordinated system. The synchronization module combines information about garbage collection and code optimization schedules from multiple JVMs and creates a unified coordination plan that reduces resource usage volatility while maintaining autonomous management capabilities.
Solution Approach 2:
The system dynamically adjusts the timing of garbage collection and code optimization operations based on real-time resource usage patterns and predicted future states. The synchronization module continuously monitors and adapts the coordination strategy to balance autonomous management with volatility reduction.
2Reliability
If larger safety margins are provided for JVM resource usage, then resource availability is ensured during transient spikes, but virtualization savings are reduced
Solution Approach 1:
The synchronization module performs preliminary actions by predicting future garbage collection and code optimization events, then proactively coordinating these events before they occur. This allows the system to prepare for transient resource spikes in advance, ensuring resource availability while minimizing the size of safety margins needed.
3Productivity
If multiple JVMs run on a single physical server, then resource utilization efficiency improves and energy waste is reduced, but transient resource usage volatility increases
Solution Approach 1:
The synchronization module implements a feedback mechanism that continuously monitors resource usage patterns across multiple JVMs and uses this information to adjust coordination strategies. The system learns from past resource usage behavior and refines its predictions and coordination actions to maintain low volatility while preserving high resource utilization efficiency.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A system and method for synchronizing transient resource usage between virtual machines, e.g. Java Virtual Machines (JVMs), running within a hypervisor. In accordance with an embodiment, the system allows for synchronizing garbage collection and code optimization to reduce transient processor (cpu) and memory usage. In accordance with an embodiment, the system comprises a computer; a hypervisor for executing virtual servers running JVMs; a communication channel between the virtual servers; wherein each virtual server further comprises non-transient and transient memory and a synchronization module. In accordance with an embodiment the synchronization modules schedule garbage collects and code optimizations to minimize overlaps, thereby reducing the peak transient memory and cpu usage and the resulting volatility of transient resource usage within a computer. In accordance with another embodiment, a cloud manager can move virtual servers between computers to optimize computer volatility within a cloud.