Virtual Time Object for Multicore VM Performance
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing virtualization technologies face challenges in efficiently tracking virtual time in virtual machines (VMs) with multiple virtual processing cores, leading to performance degradation and inability to match desired performance characteristics for multicore applications.
Innovation Solution
A host computer system that includes a virtual time object stored in host memory, allowing multiple virtual cores to execute threads in parallel while designating one core to increment the virtual time object, then moving the designation to another core based on events, thereby distributing timekeeping without synchronizing with wall-clock time.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If threads are executed serially in an incremental manner, then synchronization is achieved, but VM performance degrades
Solution Approach 1:
The patent segments the timekeeping function by creating a separate virtual time object and timer mechanism that operates independently from thread execution. Each virtual core can execute threads in parallel while the virtual time system independently tracks elapsed time through instruction counting, eliminating the need for serial synchronization while maintaining timing accuracy.
Solution Approach 2:
The patent introduces a virtual time object as an intermediary between the parallel thread execution and the timing/synchronization requirements. This virtual time object acts as a mediator that decouples the timing function from the execution flow, allowing threads to run in parallel without requiring serial coordination for time tracking.
2Reliability
If virtual time is synchronized with wall clock time, then time synchronization is achieved, but performance matches cannot be achieved when processor emulation is used
Solution Approach 1:
The patent changes the fundamental parameter of time measurement from wall clock time to instruction-based virtual time. Instead of measuring elapsed real time, the system counts the number of instructions executed by each virtual core and uses this instruction count as the basis for virtual time advancement. This parameter change allows the virtual time to advance at any rate independent of real time, enabling both slow emulation and fast-forward execution modes.
3Productivity
If all virtual cores increment virtual time simultaneously, then parallel execution is maximized, but cache coherency issues arise
Solution Approach 1:
The patent extracts the timekeeping function from the virtual core execution logic and places it in a separate, shared virtual time object. Instead of each virtual core independently incrementing a time variable (which would cause cache coherency problems), the timekeeping is taken out as a separate mechanism that counts instructions and updates the shared virtual time object in a coordinated manner.
Solution Approach 2:
Each virtual core serves itself by maintaining its own instruction count locally, and only the designated timekeeping core increments the shared virtual time object. This self-service approach eliminates the need for frequent inter-core communication and cache synchronization, as each core independently tracks its own execution progress while the system as a whole maintains accurate virtual time.
Data Source
AI summary
A host computer for virtualizing a target multicore processor includes a host CPU and a host memory storing a virtual time object and a VM, the VM including target code. The host CPU executes the plurality of threads in parallel on corresponding virtual cores, including a first thread executing on a first virtual core and a second thread executing on a second virtual core. The VM assigns a designation to the first virtual core to increment the virtual time object by a first count of a first plurality of instructions executed in the first thread over a first duration. The VM moves the designation to the second virtual core in response to detecting an event that defines an end of the first duration. The second virtual core increments the virtual time object by a second count of instructions executed in the second thread over a second duration.